1 /* Support for GCC plugin mechanism.
2 Copyright (C) 2009, 2010 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)
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. */
26 /* If plugin support is not enabled, do not try to execute any code
27 that may reference libdl. The generic code is still compiled in to
28 avoid including too many conditional compilation paths in the rest
34 #include "coretypes.h"
37 #include "tree-pass.h"
44 #include "plugin-version.h"
47 #define GCC_PLUGIN_STRINGIFY0(X) #X
48 #define GCC_PLUGIN_STRINGIFY1(X) GCC_PLUGIN_STRINGIFY0 (X)
50 /* Event names as strings. Keep in sync with enum plugin_event. */
51 static const char *plugin_event_name_init[] =
53 # define DEFEVENT(NAME) GCC_PLUGIN_STRINGIFY1 (NAME),
54 # include "plugin.def"
58 /* A printf format large enough for the largest event above. */
59 #define FMT_FOR_PLUGIN_EVENT "%-32s"
61 const char **plugin_event_name = plugin_event_name_init;
63 /* A hash table to map event names to the position of the names in the
64 plugin_event_name table. */
65 static htab_t event_tab;
67 /* Keep track of the limit of allocated events and space ready for
69 static int event_last = PLUGIN_EVENT_FIRST_DYNAMIC;
70 static int event_horizon = PLUGIN_EVENT_FIRST_DYNAMIC;
72 /* Hash table for the plugin_name_args objects created during command-line
74 static htab_t plugin_name_args_tab = NULL;
76 /* List node for keeping track of plugin-registered callback. */
79 const char *plugin_name; /* Name of plugin that registers the callback. */
80 plugin_callback_func func; /* Callback to be called. */
81 void *user_data; /* plugin-specified data. */
82 struct callback_info *next;
85 /* An array of lists of 'callback_info' objects indexed by the event id. */
86 static struct callback_info *plugin_callbacks_init[PLUGIN_EVENT_FIRST_DYNAMIC];
87 static struct callback_info **plugin_callbacks = plugin_callbacks_init;
89 /* For invoke_plugin_callbacks(), see plugin.h. */
90 bool flag_plugin_added = false;
93 /* Each plugin should define an initialization function with exactly
95 static const char *str_plugin_init_func_name = "plugin_init";
97 /* Each plugin should define this symbol to assert that it is
98 distributed under a GPL-compatible license. */
99 static const char *str_license = "plugin_is_GPL_compatible";
102 /* Helper function for the hash table that compares the base_name of the
103 existing entry (S1) with the given string (S2). */
106 htab_str_eq (const void *s1, const void *s2)
108 const struct plugin_name_args *plugin = (const struct plugin_name_args *) s1;
109 return !strcmp (plugin->base_name, (const char *) s2);
113 /* Given a plugin's full-path name FULL_NAME, e.g. /pass/to/NAME.so,
117 get_plugin_base_name (const char *full_name)
119 /* First get the base name part of the full-path name, i.e. NAME.so. */
120 char *base_name = xstrdup (lbasename (full_name));
122 /* Then get rid of '.so' part of the name. */
123 strip_off_ending (base_name, strlen (base_name));
129 /* Create a plugin_name_args object for the given plugin and insert it
130 to the hash table. This function is called when
131 -fplugin=/path/to/NAME.so or -fplugin=NAME option is processed. */
134 add_new_plugin (const char* plugin_name)
136 struct plugin_name_args *plugin;
142 /* Replace short names by their full path when relevant. */
143 name_is_short = !IS_ABSOLUTE_PATH (plugin_name);
144 for (pc = plugin_name; name_is_short && *pc; pc++)
145 if (*pc == '.' || IS_DIR_SEPARATOR (*pc))
146 name_is_short = false;
150 base_name = CONST_CAST (char*, plugin_name);
151 /* FIXME: the ".so" suffix is currently builtin, since plugins
152 only work on ELF host systems like e.g. Linux or Solaris.
153 When plugins shall be available on non ELF systems such as
154 Windows or MacOS, this code has to be greatly improved. */
155 plugin_name = concat (default_plugin_dir_name (), "/",
156 plugin_name, ".so", NULL);
157 if (access (plugin_name, R_OK))
159 ("inacessible plugin file %s expanded from short plugin name %s: %m",
160 plugin_name, base_name);
163 base_name = get_plugin_base_name (plugin_name);
165 /* If this is the first -fplugin= option we encounter, create
166 'plugin_name_args_tab' hash table. */
167 if (!plugin_name_args_tab)
168 plugin_name_args_tab = htab_create (10, htab_hash_string, htab_str_eq,
171 slot = htab_find_slot (plugin_name_args_tab, base_name, INSERT);
173 /* If the same plugin (name) has been specified earlier, either emit an
174 error or a warning message depending on if they have identical full
178 plugin = (struct plugin_name_args *) *slot;
179 if (strcmp (plugin->full_name, plugin_name))
180 error ("Plugin %s was specified with different paths:\n%s\n%s",
181 plugin->base_name, plugin->full_name, plugin_name);
185 plugin = XCNEW (struct plugin_name_args);
186 plugin->base_name = base_name;
187 plugin->full_name = plugin_name;
193 /* Parse the -fplugin-arg-<name>-<key>[=<value>] option and create a
194 'plugin_argument' object for the parsed key-value pair. ARG is
195 the <name>-<key>[=<value>] part of the option. */
198 parse_plugin_arg_opt (const char *arg)
200 size_t len = 0, name_len = 0, key_len = 0, value_len = 0;
201 const char *ptr, *name_start = arg, *key_start = NULL, *value_start = NULL;
202 char *name, *key, *value;
204 bool name_parsed = false, key_parsed = false;
206 /* Iterate over the ARG string and identify the starting character position
207 of 'name', 'key', and 'value' and their lengths. */
208 for (ptr = arg; *ptr; ++ptr)
210 /* Only the first '-' encountered is considered a separator between
211 'name' and 'key'. All the subsequent '-'s are considered part of
212 'key'. For example, given -fplugin-arg-foo-bar-primary-key=value,
213 the plugin name is 'foo' and the key is 'bar-primary-key'. */
214 if (*ptr == '-' && !name_parsed)
222 else if (*ptr == '=')
226 error ("Malformed option -fplugin-arg-%s (multiple '=' signs)",
232 value_start = ptr + 1;
242 error ("Malformed option -fplugin-arg-%s (missing -<key>[=<value>])",
247 /* If the option doesn't contain the 'value' part, LEN is the KEY_LEN.
248 Otherwise, it is the VALUE_LEN. */
254 name = XNEWVEC (char, name_len + 1);
255 strncpy (name, name_start, name_len);
256 name[name_len] = '\0';
258 /* Check if the named plugin has already been specified earlier in the
260 if (plugin_name_args_tab
261 && ((slot = htab_find_slot (plugin_name_args_tab, name, NO_INSERT))
264 struct plugin_name_args *plugin = (struct plugin_name_args *) *slot;
266 key = XNEWVEC (char, key_len + 1);
267 strncpy (key, key_start, key_len);
271 value = XNEWVEC (char, value_len + 1);
272 strncpy (value, value_start, value_len);
273 value[value_len] = '\0';
278 /* Create a plugin_argument object for the parsed key-value pair.
279 If there are already arguments for this plugin, we will need to
280 adjust the argument array size by creating a new array and deleting
281 the old one. If the performance ever becomes an issue, we can
282 change the code by pre-allocating a larger array first. */
283 if (plugin->argc > 0)
285 struct plugin_argument *args = XNEWVEC (struct plugin_argument,
287 memcpy (args, plugin->argv,
288 sizeof (struct plugin_argument) * plugin->argc);
289 XDELETEVEC (plugin->argv);
295 gcc_assert (plugin->argv == NULL);
296 plugin->argv = XNEWVEC (struct plugin_argument, 1);
300 plugin->argv[plugin->argc - 1].key = key;
301 plugin->argv[plugin->argc - 1].value = value;
304 error ("Plugin %s should be specified before -fplugin-arg-%s "
305 "in the command line", name, arg);
307 /* We don't need the plugin's name anymore. Just release it. */
311 /* Register additional plugin information. NAME is the name passed to
312 plugin_init. INFO is the information that should be registered. */
315 register_plugin_info (const char* name, struct plugin_info *info)
317 void **slot = htab_find_slot (plugin_name_args_tab, name, NO_INSERT);
318 struct plugin_name_args *plugin = (struct plugin_name_args *) *slot;
319 plugin->version = info->version;
320 plugin->help = info->help;
323 /* Helper function for the event hash table that compares the name of an
324 existing entry (E1) with the given string (S2). */
327 htab_event_eq (const void *e1, const void *s2)
329 const char *s1= *(const char * const *) e1;
330 return !strcmp (s1, (const char *) s2);
333 /* Look up the event id for NAME. If the name is not found, return -1
334 if INSERT is NO_INSERT. */
337 get_named_event_id (const char *name, enum insert_option insert)
345 event_tab = htab_create (150, htab_hash_string, htab_event_eq, NULL);
346 for (i = 0; i < event_last; i++)
348 slot = htab_find_slot (event_tab, plugin_event_name[i], INSERT);
349 gcc_assert (*slot == HTAB_EMPTY_ENTRY);
350 *slot = &plugin_event_name[i];
353 slot = htab_find_slot (event_tab, name, insert);
356 if (*slot != HTAB_EMPTY_ENTRY)
357 return (const char **) *slot - &plugin_event_name[0];
359 if (event_last >= event_horizon)
361 event_horizon = event_last * 2;
362 if (plugin_event_name == plugin_event_name_init)
364 plugin_event_name = XNEWVEC (const char *, event_horizon);
365 memcpy (plugin_event_name, plugin_event_name_init,
366 sizeof plugin_event_name_init);
367 plugin_callbacks = XNEWVEC (struct callback_info *, event_horizon);
368 memcpy (plugin_callbacks, plugin_callbacks_init,
369 sizeof plugin_callbacks_init);
374 = XRESIZEVEC (const char *, plugin_event_name, event_horizon);
375 plugin_callbacks = XRESIZEVEC (struct callback_info *,
376 plugin_callbacks, event_horizon);
378 /* All the pointers in the hash table will need to be updated. */
379 htab_delete (event_tab);
383 *slot = &plugin_event_name[event_last];
384 plugin_event_name[event_last] = name;
388 /* Called from the plugin's initialization code. Register a single callback.
389 This function can be called multiple times.
391 PLUGIN_NAME - display name for this plugin
392 EVENT - which event the callback is for
393 CALLBACK - the callback to be called at the event
394 USER_DATA - plugin-provided data */
397 register_callback (const char *plugin_name,
399 plugin_callback_func callback,
404 case PLUGIN_PASS_MANAGER_SETUP:
405 gcc_assert (!callback);
406 register_pass ((struct register_pass_info *) user_data);
409 gcc_assert (!callback);
410 register_plugin_info (plugin_name, (struct plugin_info *) user_data);
412 case PLUGIN_REGISTER_GGC_ROOTS:
413 gcc_assert (!callback);
414 ggc_register_root_tab ((const struct ggc_root_tab*) user_data);
416 case PLUGIN_REGISTER_GGC_CACHES:
417 gcc_assert (!callback);
418 ggc_register_cache_tab ((const struct ggc_cache_tab*) user_data);
420 case PLUGIN_EVENT_FIRST_DYNAMIC:
422 if (event < PLUGIN_EVENT_FIRST_DYNAMIC || event >= event_last)
424 error ("Unknown callback event registered by plugin %s",
429 case PLUGIN_FINISH_TYPE:
430 case PLUGIN_START_UNIT:
431 case PLUGIN_FINISH_UNIT:
432 case PLUGIN_PRE_GENERICIZE:
433 case PLUGIN_GGC_START:
434 case PLUGIN_GGC_MARKING:
436 case PLUGIN_ATTRIBUTES:
439 case PLUGIN_ALL_PASSES_START:
440 case PLUGIN_ALL_PASSES_END:
441 case PLUGIN_ALL_IPA_PASSES_START:
442 case PLUGIN_ALL_IPA_PASSES_END:
443 case PLUGIN_OVERRIDE_GATE:
444 case PLUGIN_PASS_EXECUTION:
445 case PLUGIN_EARLY_GIMPLE_PASSES_START:
446 case PLUGIN_EARLY_GIMPLE_PASSES_END:
447 case PLUGIN_NEW_PASS:
449 struct callback_info *new_callback;
452 error ("Plugin %s registered a null callback function "
453 "for event %s", plugin_name, plugin_event_name[event]);
456 new_callback = XNEW (struct callback_info);
457 new_callback->plugin_name = plugin_name;
458 new_callback->func = callback;
459 new_callback->user_data = user_data;
460 new_callback->next = plugin_callbacks[event];
461 plugin_callbacks[event] = new_callback;
467 /* Remove a callback for EVENT which has been registered with for a plugin
468 PLUGIN_NAME. Return PLUGEVT_SUCCESS if a matching callback was
469 found & removed, PLUGEVT_NO_CALLBACK if the event does not have a matching
470 callback, and PLUGEVT_NO_SUCH_EVENT if EVENT is invalid. */
472 unregister_callback (const char *plugin_name, int event)
474 struct callback_info *callback, **cbp;
476 if (event >= event_last)
477 return PLUGEVT_NO_SUCH_EVENT;
479 for (cbp = &plugin_callbacks[event]; (callback = *cbp); cbp = &callback->next)
480 if (strcmp (callback->plugin_name, plugin_name) == 0)
482 *cbp = callback->next;
483 return PLUGEVT_SUCCESS;
485 return PLUGEVT_NO_CALLBACK;
488 /* Invoke all plugin callbacks registered with the specified event,
489 called from invoke_plugin_callbacks(). */
492 invoke_plugin_callbacks_full (int event, void *gcc_data)
494 int retval = PLUGEVT_SUCCESS;
496 timevar_push (TV_PLUGIN_RUN);
500 case PLUGIN_EVENT_FIRST_DYNAMIC:
502 gcc_assert (event >= PLUGIN_EVENT_FIRST_DYNAMIC);
503 gcc_assert (event < event_last);
505 case PLUGIN_FINISH_TYPE:
506 case PLUGIN_START_UNIT:
507 case PLUGIN_FINISH_UNIT:
508 case PLUGIN_PRE_GENERICIZE:
509 case PLUGIN_ATTRIBUTES:
512 case PLUGIN_GGC_START:
513 case PLUGIN_GGC_MARKING:
515 case PLUGIN_ALL_PASSES_START:
516 case PLUGIN_ALL_PASSES_END:
517 case PLUGIN_ALL_IPA_PASSES_START:
518 case PLUGIN_ALL_IPA_PASSES_END:
519 case PLUGIN_OVERRIDE_GATE:
520 case PLUGIN_PASS_EXECUTION:
521 case PLUGIN_EARLY_GIMPLE_PASSES_START:
522 case PLUGIN_EARLY_GIMPLE_PASSES_END:
523 case PLUGIN_NEW_PASS:
525 /* Iterate over every callback registered with this event and
527 struct callback_info *callback = plugin_callbacks[event];
530 retval = PLUGEVT_NO_CALLBACK;
531 for ( ; callback; callback = callback->next)
532 (*callback->func) (gcc_data, callback->user_data);
536 case PLUGIN_PASS_MANAGER_SETUP:
537 case PLUGIN_REGISTER_GGC_ROOTS:
538 case PLUGIN_REGISTER_GGC_CACHES:
542 timevar_pop (TV_PLUGIN_RUN);
547 /* We need a union to cast dlsym return value to a function pointer
548 as ISO C forbids assignment between function pointer and 'void *'.
549 Use explicit union instead of __extension__(<union_cast>) for
551 #define PTR_UNION_TYPE(TOTYPE) union { void *_q; TOTYPE _nq; }
552 #define PTR_UNION_AS_VOID_PTR(NAME) (NAME._q)
553 #define PTR_UNION_AS_CAST_PTR(NAME) (NAME._nq)
555 /* Try to initialize PLUGIN. Return true if successful. */
558 try_init_one_plugin (struct plugin_name_args *plugin)
561 plugin_init_func plugin_init;
563 PTR_UNION_TYPE (plugin_init_func) plugin_init_union;
565 /* We use RTLD_NOW to accelerate binding and detect any mismatch
566 between the API expected by the plugin and the GCC API; we use
567 RTLD_GLOBAL which is useful to plugins which themselves call
569 dl_handle = dlopen (plugin->full_name, RTLD_NOW | RTLD_GLOBAL);
572 error ("Cannot load plugin %s\n%s", plugin->full_name, dlerror ());
576 /* Clear any existing error. */
579 /* Check the plugin license. */
580 if (dlsym (dl_handle, str_license) == NULL)
581 fatal_error ("plugin %s is not licensed under a GPL-compatible license\n"
582 "%s", plugin->full_name, dlerror ());
584 PTR_UNION_AS_VOID_PTR (plugin_init_union) =
585 dlsym (dl_handle, str_plugin_init_func_name);
586 plugin_init = PTR_UNION_AS_CAST_PTR (plugin_init_union);
588 if ((err = dlerror ()) != NULL)
590 error ("Cannot find %s in plugin %s\n%s", str_plugin_init_func_name,
591 plugin->full_name, err);
595 /* Call the plugin-provided initialization routine with the arguments. */
596 if ((*plugin_init) (plugin, &gcc_version))
598 error ("Fail to initialize plugin %s", plugin->full_name);
606 /* Routine to dlopen and initialize one plugin. This function is passed to
607 (and called by) the hash table traverse routine. Return 1 for the
608 htab_traverse to continue scan, 0 to stop.
610 SLOT - slot of the hash table element
611 INFO - auxiliary pointer handed to hash table traverse routine
612 (unused in this function) */
615 init_one_plugin (void **slot, void * ARG_UNUSED (info))
617 struct plugin_name_args *plugin = (struct plugin_name_args *) *slot;
618 bool ok = try_init_one_plugin (plugin);
621 htab_remove_elt (plugin_name_args_tab, plugin->base_name);
627 #endif /* ENABLE_PLUGIN */
629 /* Main plugin initialization function. Called from compile_file() in
633 initialize_plugins (void)
635 /* If no plugin was specified in the command-line, simply return. */
636 if (!plugin_name_args_tab)
639 timevar_push (TV_PLUGIN_INIT);
642 /* Traverse and initialize each plugin specified in the command-line. */
643 htab_traverse_noresize (plugin_name_args_tab, init_one_plugin, NULL);
646 timevar_pop (TV_PLUGIN_INIT);
649 /* Release memory used by one plugin. */
652 finalize_one_plugin (void **slot, void * ARG_UNUSED (info))
654 struct plugin_name_args *plugin = (struct plugin_name_args *) *slot;
659 /* Free memory allocated by the plugin system. */
662 finalize_plugins (void)
664 if (!plugin_name_args_tab)
667 /* We can now delete the plugin_name_args object as it will no longer
668 be used. Note that base_name and argv fields (both of which were also
669 dynamically allocated) are not freed as they could still be used by
672 htab_traverse_noresize (plugin_name_args_tab, finalize_one_plugin, NULL);
674 /* PLUGIN_NAME_ARGS_TAB is no longer needed, just delete it. */
675 htab_delete (plugin_name_args_tab);
676 plugin_name_args_tab = NULL;
679 /* Used to pass options to htab_traverse callbacks. */
687 /* Print the version of one plugin. */
690 print_version_one_plugin (void **slot, void *data)
692 struct print_options *opt = (struct print_options *) data;
693 struct plugin_name_args *plugin = (struct plugin_name_args *) *slot;
694 const char *version = plugin->version ? plugin->version : "Unknown version.";
696 fprintf (opt->file, " %s%s: %s\n", opt->indent, plugin->base_name, version);
700 /* Print the version of each plugin. */
703 print_plugins_versions (FILE *file, const char *indent)
705 struct print_options opt;
708 if (!plugin_name_args_tab || htab_elements (plugin_name_args_tab) == 0)
711 fprintf (file, "%sVersions of loaded plugins:\n", indent);
712 htab_traverse_noresize (plugin_name_args_tab, print_version_one_plugin, &opt);
715 /* Print help for one plugin. SLOT is the hash table slot. DATA is the
716 argument to htab_traverse_noresize. */
719 print_help_one_plugin (void **slot, void *data)
721 struct print_options *opt = (struct print_options *) data;
722 struct plugin_name_args *plugin = (struct plugin_name_args *) *slot;
723 const char *help = plugin->help ? plugin->help : "No help available .";
725 char *dup = xstrdup (help);
727 fprintf (opt->file, " %s%s:\n", opt->indent, plugin->base_name);
729 for (p = nl = dup; nl; p = nl)
731 nl = strchr (nl, '\n');
737 fprintf (opt->file, " %s %s\n", opt->indent, p);
744 /* Print help for each plugin. The output goes to FILE and every line starts
748 print_plugins_help (FILE *file, const char *indent)
750 struct print_options opt;
753 if (!plugin_name_args_tab || htab_elements (plugin_name_args_tab) == 0)
756 fprintf (file, "%sHelp for the loaded plugins:\n", indent);
757 htab_traverse_noresize (plugin_name_args_tab, print_help_one_plugin, &opt);
761 /* Return true if plugins have been loaded. */
764 plugins_active_p (void)
768 for (event = PLUGIN_PASS_MANAGER_SETUP; event < event_last; event++)
769 if (plugin_callbacks[event])
776 /* Dump to FILE the names and associated events for all the active
780 dump_active_plugins (FILE *file)
784 if (!plugins_active_p ())
787 fprintf (file, FMT_FOR_PLUGIN_EVENT " | %s\n", _("Event"), _("Plugins"));
788 for (event = PLUGIN_PASS_MANAGER_SETUP; event < event_last; event++)
789 if (plugin_callbacks[event])
791 struct callback_info *ci;
793 fprintf (file, FMT_FOR_PLUGIN_EVENT " |", plugin_event_name[event]);
795 for (ci = plugin_callbacks[event]; ci; ci = ci->next)
796 fprintf (file, " %s", ci->plugin_name);
803 /* Dump active plugins to stderr. */
806 debug_active_plugins (void)
808 dump_active_plugins (stderr);
811 /* The default version check. Compares every field in VERSION. */
814 plugin_default_version_check (struct plugin_gcc_version *gcc_version,
815 struct plugin_gcc_version *plugin_version)
817 if (!gcc_version || !plugin_version)
820 if (strcmp (gcc_version->basever, plugin_version->basever))
822 if (strcmp (gcc_version->datestamp, plugin_version->datestamp))
824 if (strcmp (gcc_version->devphase, plugin_version->devphase))
826 if (strcmp (gcc_version->revision, plugin_version->revision))
828 if (strcmp (gcc_version->configuration_arguments,
829 plugin_version->configuration_arguments))
835 /* Return the current value of event_last, so that plugins which provide
836 additional functionality for events for the benefit of high-level plugins
837 know how many valid entries plugin_event_name holds. */
840 get_event_last (void)
846 /* Retrieve the default plugin directory. The gcc driver should have passed
847 it as -iplugindir <dir> to the cc1 program, and it is queriable thru the
848 -print-file-name=plugin option to gcc. */
850 default_plugin_dir_name (void)
852 if (!plugindir_string)
853 fatal_error ("-iplugindir <dir> option not passed from the gcc driver");
854 return plugindir_string;