1 /* Support for GCC plugin mechanism.
2 Copyright (C) 2009 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 to many conditional compilation paths in the rest
34 #include "coretypes.h"
37 #include "tree-pass.h"
42 /* Event names as strings. Keep in sync with enum plugin_event. */
43 const char *plugin_event_name
[] =
45 "PLUGIN_PASS_MANAGER_SETUP",
48 "PLUGIN_CXX_CP_PRE_GENERICIZE",
54 /* Object that keeps track of the plugin name and its arguments
55 when parsing the command-line options -fplugin=/path/to/NAME.so and
56 -fplugin-arg-NAME-<key>[=<value>]. */
57 struct plugin_name_args
60 const char *full_name
;
62 struct plugin_argument
*argv
;
67 /* Hash table for the plugin_name_args objects created during command-line
69 static htab_t plugin_name_args_tab
= NULL
;
71 /* List node for keeping track of plugin-registered callback. */
74 const char *plugin_name
; /* Name of plugin that registers the callback. */
75 plugin_callback_func func
; /* Callback to be called. */
76 void *user_data
; /* plugin-specified data. */
77 struct callback_info
*next
;
80 /* An array of lists of 'callback_info' objects indexed by the event id. */
81 static struct callback_info
*plugin_callbacks
[PLUGIN_EVENT_LAST
] = { NULL
};
83 /* List node for an inserted pass instance. We need to keep track of all
84 the newly-added pass instances (with 'added_pass_nodes' defined below)
85 so that we can register their dump files after pass-positioning is finished.
86 Registering dumping files needs to be post-processed or the
87 static_pass_number of the opt_pass object would be modified and mess up
88 the dump file names of future pass instances to be added. */
91 struct opt_pass
*pass
;
92 struct pass_list_node
*next
;
95 static struct pass_list_node
*added_pass_nodes
= NULL
;
96 static struct pass_list_node
*prev_added_pass_node
;
99 /* Each plugin should define an initialization function with exactly
101 static const char *str_plugin_init_func_name
= "plugin_init";
104 /* Helper function for the hash table that compares the base_name of the
105 existing entry (S1) with the given string (S2). */
108 htab_str_eq (const void *s1
, const void *s2
)
110 const struct plugin_name_args
*plugin
= (const struct plugin_name_args
*) s1
;
111 return !strcmp (plugin
->base_name
, (const char *) s2
);
115 /* Given a plugin's full-path name FULL_NAME, e.g. /pass/to/NAME.so,
119 get_plugin_base_name (const char *full_name
)
121 /* First get the base name part of the full-path name, i.e. NAME.so. */
122 char *base_name
= xstrdup (lbasename (full_name
));
124 /* Then get rid of '.so' part of the name. */
125 strip_off_ending (base_name
, strlen (base_name
));
131 /* Create a plugin_name_args object for the give plugin and insert it to
132 the hash table. This function is called when -fplugin=/path/to/NAME.so
133 option is processed. */
136 add_new_plugin (const char* plugin_name
)
138 struct plugin_name_args
*plugin
;
140 char *base_name
= get_plugin_base_name (plugin_name
);
142 /* If this is the first -fplugin= option we encounter, create
143 'plugin_name_args_tab' hash table. */
144 if (!plugin_name_args_tab
)
145 plugin_name_args_tab
= htab_create (10, htab_hash_string
, htab_str_eq
,
148 slot
= htab_find_slot (plugin_name_args_tab
, base_name
, INSERT
);
150 /* If the same plugin (name) has been specified earlier, either emit an
151 error or a warning message depending on if they have identical full
155 plugin
= (struct plugin_name_args
*) *slot
;
156 if (strcmp (plugin
->full_name
, plugin_name
))
157 error ("Plugin %s was specified with different paths:\n%s\n%s",
158 plugin
->base_name
, plugin
->full_name
, plugin_name
);
162 plugin
= XCNEW (struct plugin_name_args
);
163 plugin
->base_name
= base_name
;
164 plugin
->full_name
= plugin_name
;
170 /* Parse the -fplugin-arg-<name>-<key>[=<value>] option and create a
171 'plugin_argument' object for the parsed key-value pair. ARG is
172 the <name>-<key>[=<value>] part of the option. */
175 parse_plugin_arg_opt (const char *arg
)
177 size_t len
= 0, name_len
= 0, key_len
= 0, value_len
= 0;
178 const char *ptr
, *name_start
= arg
, *key_start
= NULL
, *value_start
= NULL
;
179 char *name
, *key
, *value
;
181 bool name_parsed
= false, key_parsed
= false;
183 /* Iterate over the ARG string and identify the starting character position
184 of 'name', 'key', and 'value' and their lengths. */
185 for (ptr
= arg
; *ptr
; ++ptr
)
187 /* Only the first '-' encountered is considered a separator between
188 'name' and 'key'. All the subsequent '-'s are considered part of
189 'key'. For example, given -fplugin-arg-foo-bar-primary-key=value,
190 the plugin name is 'foo' and the key is 'bar-primary-key'. */
191 if (*ptr
== '-' && !name_parsed
)
199 else if (*ptr
== '=')
203 error ("Malformed option -fplugin-arg-%s (multiple '=' signs)",
209 value_start
= ptr
+ 1;
219 error ("Malformed option -fplugin-arg-%s (missing -<key>[=<value>])",
224 /* If the option doesn't contain the 'value' part, LEN is the KEY_LEN.
225 Otherwise, it is the VALUE_LEN. */
231 name
= XNEWVEC (char, name_len
+ 1);
232 strncpy (name
, name_start
, name_len
);
233 name
[name_len
] = '\0';
235 /* Check if the named plugin has already been specified earlier in the
237 if (plugin_name_args_tab
238 && ((slot
= htab_find_slot (plugin_name_args_tab
, name
, NO_INSERT
))
241 struct plugin_name_args
*plugin
= (struct plugin_name_args
*) *slot
;
243 key
= XNEWVEC (char, key_len
+ 1);
244 strncpy (key
, key_start
, key_len
);
248 value
= XNEWVEC (char, value_len
+ 1);
249 strncpy (value
, value_start
, value_len
);
250 value
[value_len
] = '\0';
255 /* Create a plugin_argument object for the parsed key-value pair.
256 If there are already arguments for this plugin, we will need to
257 adjust the argument array size by creating a new array and deleting
258 the old one. If the performance ever becomes an issue, we can
259 change the code by pre-allocating a larger array first. */
260 if (plugin
->argc
> 0)
262 struct plugin_argument
*args
= XNEWVEC (struct plugin_argument
,
264 memcpy (args
, plugin
->argv
,
265 sizeof (struct plugin_argument
) * plugin
->argc
);
266 XDELETEVEC (plugin
->argv
);
272 gcc_assert (plugin
->argv
== NULL
);
273 plugin
->argv
= XNEWVEC (struct plugin_argument
, 1);
277 plugin
->argv
[plugin
->argc
- 1].key
= key
;
278 plugin
->argv
[plugin
->argc
- 1].value
= value
;
281 error ("Plugin %s should be specified before -fplugin-arg-%s "
282 "in the command line", name
, arg
);
284 /* We don't need the plugin's name anymore. Just release it. */
289 /* Insert the plugin pass at the proper position. Return true if the pass
290 is successfully added.
292 PLUGIN_PASS_INFO - new pass to be inserted
293 PASS_LIST - root of the pass list to insert the new pass to */
296 position_pass (struct plugin_pass
*plugin_pass_info
,
297 struct opt_pass
**pass_list
)
299 struct opt_pass
*pass
= *pass_list
, *prev_pass
= NULL
;
300 bool success
= false;
302 for ( ; pass
; prev_pass
= pass
, pass
= pass
->next
)
304 /* Check if the current pass is of the same type as the new pass and
305 matches the name and the instance number of the reference pass. */
306 if (pass
->type
== plugin_pass_info
->pass
->type
308 && !strcmp (pass
->name
, plugin_pass_info
->reference_pass_name
)
309 && ((plugin_pass_info
->ref_pass_instance_number
== 0)
310 || (plugin_pass_info
->ref_pass_instance_number
==
311 pass
->static_pass_number
)
312 || (plugin_pass_info
->ref_pass_instance_number
== 1
313 && pass
->todo_flags_start
& TODO_mark_first_instance
)))
315 struct opt_pass
*new_pass
= plugin_pass_info
->pass
;
316 struct pass_list_node
*new_pass_node
;
318 /* The following code (if-statement) is adopted from next_pass_1. */
319 if (new_pass
->static_pass_number
)
321 new_pass
= XNEW (struct opt_pass
);
322 memcpy (new_pass
, plugin_pass_info
->pass
, sizeof (*new_pass
));
323 new_pass
->next
= NULL
;
325 new_pass
->todo_flags_start
&= ~TODO_mark_first_instance
;
327 plugin_pass_info
->pass
->static_pass_number
-= 1;
328 new_pass
->static_pass_number
=
329 -plugin_pass_info
->pass
->static_pass_number
;
333 new_pass
->todo_flags_start
|= TODO_mark_first_instance
;
334 new_pass
->static_pass_number
= -1;
337 /* Insert the new pass instance based on the positioning op. */
338 switch (plugin_pass_info
->pos_op
)
340 case PASS_POS_INSERT_AFTER
:
341 new_pass
->next
= pass
->next
;
342 pass
->next
= new_pass
;
344 case PASS_POS_INSERT_BEFORE
:
345 new_pass
->next
= pass
;
347 prev_pass
->next
= new_pass
;
349 *pass_list
= new_pass
;
351 case PASS_POS_REPLACE
:
352 new_pass
->next
= pass
->next
;
354 prev_pass
->next
= new_pass
;
356 *pass_list
= new_pass
;
357 new_pass
->sub
= pass
->sub
;
358 new_pass
->tv_id
= pass
->tv_id
;
362 error ("Invalid pass positioning operation");
366 /* Save the newly added pass (instance) in the added_pass_nodes
367 list so that we can register its dump file later. Note that
368 we cannot register the dump file now because doing so will modify
369 the static_pass_number of the opt_pass object and therefore
370 mess up the dump file name of future instances. */
371 new_pass_node
= XCNEW (struct pass_list_node
);
372 new_pass_node
->pass
= new_pass
;
373 if (!added_pass_nodes
)
374 added_pass_nodes
= new_pass_node
;
376 prev_added_pass_node
->next
= new_pass_node
;
377 prev_added_pass_node
= new_pass_node
;
382 if (pass
->sub
&& position_pass (plugin_pass_info
, &pass
->sub
))
390 /* Hook into the pass lists (trees) a new pass registered by a plugin.
392 PLUGIN_NAME - display name for the plugin
393 PASS_INFO - plugin pass information that specifies the opt_pass object,
394 reference pass, instance number, and how to position
398 register_pass (const char *plugin_name
, struct plugin_pass
*pass_info
)
400 if (!pass_info
->pass
)
402 error ("No pass specified when registering a new pass in plugin %s",
407 if (!pass_info
->reference_pass_name
)
409 error ("No reference pass specified for positioning the pass "
410 " from plugin %s", plugin_name
);
414 /* Try to insert the new pass to the pass lists. We need to check all
415 three lists as the reference pass could be in one (or all) of them. */
416 if (!position_pass (pass_info
, &all_lowering_passes
)
417 && !position_pass (pass_info
, &all_ipa_passes
)
418 && !position_pass (pass_info
, &all_passes
))
419 error ("Failed to position pass %s registered by plugin %s. "
420 "Cannot find the (specified instance of) reference pass %s",
421 pass_info
->pass
->name
, plugin_name
, pass_info
->reference_pass_name
);
424 /* OK, we have successfully inserted the new pass. We need to register
425 the dump files for the newly added pass and its duplicates (if any).
426 Because the registration of plugin passes happens after the
427 command-line options are parsed, the options that specify single
428 pass dumping (e.g. -fdump-tree-PASSNAME) cannot be used for new
429 plugin passes. Therefore we currently can only enable dumping of
430 new plugin passes when the 'dump-all' flags (e.g. -fdump-tree-all)
431 are specified. While doing so, we also delete the pass_list_node
432 objects created during pass positioning. */
433 while (added_pass_nodes
)
435 struct pass_list_node
*next_node
= added_pass_nodes
->next
;
436 enum tree_dump_index tdi
;
437 register_one_dump_file (added_pass_nodes
->pass
);
438 if (added_pass_nodes
->pass
->type
== SIMPLE_IPA_PASS
439 || added_pass_nodes
->pass
->type
== IPA_PASS
)
441 else if (added_pass_nodes
->pass
->type
== GIMPLE_PASS
)
445 /* Check if dump-all flag is specified. */
446 if (get_dump_file_info (tdi
)->state
)
447 get_dump_file_info (added_pass_nodes
->pass
->static_pass_number
)
448 ->state
= get_dump_file_info (tdi
)->state
;
449 XDELETE (added_pass_nodes
);
450 added_pass_nodes
= next_node
;
456 /* Register additional plugin information. NAME is the name passed to
457 plugin_init. INFO is the information that should be registered. */
460 register_plugin_info (const char* name
, struct plugin_info
*info
)
462 void **slot
= htab_find_slot (plugin_name_args_tab
, name
, NO_INSERT
);
463 struct plugin_name_args
*plugin
= (struct plugin_name_args
*) *slot
;
464 plugin
->version
= info
->version
;
465 plugin
->help
= info
->help
;
468 /* Called from the plugin's initialization code. Register a single callback.
469 This function can be called multiple times.
471 PLUGIN_NAME - display name for this plugin
472 EVENT - which event the callback is for
473 CALLBACK - the callback to be called at the event
474 USER_DATA - plugin-provided data */
477 register_callback (const char *plugin_name
,
478 enum plugin_event event
,
479 plugin_callback_func callback
,
484 case PLUGIN_PASS_MANAGER_SETUP
:
485 register_pass (plugin_name
, (struct plugin_pass
*) user_data
);
488 register_plugin_info (plugin_name
, (struct plugin_info
*) user_data
);
490 case PLUGIN_FINISH_TYPE
:
491 case PLUGIN_FINISH_UNIT
:
492 case PLUGIN_CXX_CP_PRE_GENERICIZE
:
495 struct callback_info
*new_callback
;
498 error ("Plugin %s registered a null callback function "
499 "for event %s", plugin_name
, plugin_event_name
[event
]);
502 new_callback
= XNEW (struct callback_info
);
503 new_callback
->plugin_name
= plugin_name
;
504 new_callback
->func
= callback
;
505 new_callback
->user_data
= user_data
;
506 new_callback
->next
= plugin_callbacks
[event
];
507 plugin_callbacks
[event
] = new_callback
;
510 case PLUGIN_EVENT_LAST
:
512 error ("Unkown callback event registered by plugin %s",
518 /* Called from inside GCC. Invoke all plug-in callbacks registered with
521 EVENT - the event identifier
522 GCC_DATA - event-specific data provided by the compiler */
525 invoke_plugin_callbacks (enum plugin_event event
, void *gcc_data
)
527 timevar_push (TV_PLUGIN_RUN
);
531 case PLUGIN_FINISH_TYPE
:
532 case PLUGIN_FINISH_UNIT
:
533 case PLUGIN_CXX_CP_PRE_GENERICIZE
:
536 /* Iterate over every callback registered with this event and
538 struct callback_info
*callback
= plugin_callbacks
[event
];
539 for ( ; callback
; callback
= callback
->next
)
540 (*callback
->func
) (gcc_data
, callback
->user_data
);
544 case PLUGIN_PASS_MANAGER_SETUP
:
545 case PLUGIN_EVENT_LAST
:
550 timevar_pop (TV_PLUGIN_RUN
);
554 /* We need a union to cast dlsym return value to a function pointer
555 as ISO C forbids assignment between function pointer and 'void *'.
556 Use explicit union instead of __extension__(<union_cast>) for
558 #define PTR_UNION_TYPE(TOTYPE) union { void *_q; TOTYPE _nq; }
559 #define PTR_UNION_AS_VOID_PTR(NAME) (NAME._q)
560 #define PTR_UNION_AS_CAST_PTR(NAME) (NAME._nq)
562 /* Try to initialize PLUGIN. Return true if successful. */
565 try_init_one_plugin (struct plugin_name_args
*plugin
)
568 plugin_init_func plugin_init
;
570 PTR_UNION_TYPE (plugin_init_func
) plugin_init_union
;
572 dl_handle
= dlopen (plugin
->full_name
, RTLD_NOW
);
575 error ("Cannot load plugin %s\n%s", plugin
->full_name
, dlerror ());
579 /* Clear any existing error. */
582 PTR_UNION_AS_VOID_PTR (plugin_init_union
) =
583 dlsym (dl_handle
, str_plugin_init_func_name
);
584 plugin_init
= PTR_UNION_AS_CAST_PTR (plugin_init_union
);
586 if ((err
= dlerror ()) != NULL
)
588 error ("Cannot find %s in plugin %s\n%s", str_plugin_init_func_name
,
589 plugin
->full_name
, err
);
593 /* Call the plugin-provided initialization routine with the arguments. */
594 if ((*plugin_init
) (plugin
->base_name
, plugin
->argc
, plugin
->argv
))
596 error ("Fail to initialize plugin %s", plugin
->full_name
);
604 /* Routine to dlopen and initialize one plugin. This function is passed to
605 (and called by) the hash table traverse routine. Return 1 for the
606 htab_traverse to continue scan, 0 to stop.
608 SLOT - slot of the hash table element
609 INFO - auxiliary pointer handed to hash table traverse routine
610 (unused in this function) */
613 init_one_plugin (void **slot
, void * ARG_UNUSED (info
))
615 struct plugin_name_args
*plugin
= (struct plugin_name_args
*) *slot
;
616 bool ok
= try_init_one_plugin (plugin
);
619 htab_remove_elt (plugin_name_args_tab
, plugin
->base_name
);
625 #endif /* ENABLE_PLUGIN */
627 /* Main plugin initialization function. Called from compile_file() in
631 initialize_plugins (void)
633 /* If no plugin was specified in the command-line, simply return. */
634 if (!plugin_name_args_tab
)
637 timevar_push (TV_PLUGIN_INIT
);
640 /* Traverse and initialize each plugin specified in the command-line. */
641 htab_traverse_noresize (plugin_name_args_tab
, init_one_plugin
, NULL
);
644 timevar_pop (TV_PLUGIN_INIT
);
647 /* Release memory used by one plugin. */
650 finalize_one_plugin (void **slot
, void * ARG_UNUSED (info
))
652 struct plugin_name_args
*plugin
= (struct plugin_name_args
*) *slot
;
657 /* Free memory allocated by the plugin system. */
660 finalize_plugins (void)
662 if (!plugin_name_args_tab
)
665 /* We can now delete the plugin_name_args object as it will no longer
666 be used. Note that base_name and argv fields (both of which were also
667 dynamically allocated) are not freed as they could still be used by
670 htab_traverse_noresize (plugin_name_args_tab
, finalize_one_plugin
, NULL
);
672 /* PLUGIN_NAME_ARGS_TAB is no longer needed, just delete it. */
673 htab_delete (plugin_name_args_tab
);
674 plugin_name_args_tab
= NULL
;
677 /* Used to pass options to htab_traverse callbacks. */
685 /* Print the version of one plugin. */
688 print_version_one_plugin (void **slot
, void *data
)
690 struct print_options
*opt
= (struct print_options
*) data
;
691 struct plugin_name_args
*plugin
= (struct plugin_name_args
*) *slot
;
692 const char *version
= plugin
->version
? plugin
->version
: "Unknown version.";
694 fprintf (opt
->file
, " %s%s: %s\n", opt
->indent
, plugin
->base_name
, version
);
698 /* Print the version of each plugin. */
701 print_plugins_versions (FILE *file
, const char *indent
)
703 struct print_options opt
;
706 if (!plugin_name_args_tab
|| htab_elements (plugin_name_args_tab
) == 0)
709 fprintf (file
, "%sVersions of loaded plugins:\n", indent
);
710 htab_traverse_noresize (plugin_name_args_tab
, print_version_one_plugin
, &opt
);
713 /* Print help for one plugin. SLOT is the hash table slot. DATA is the
714 argument to htab_traverse_noresize. */
717 print_help_one_plugin (void **slot
, void *data
)
719 struct print_options
*opt
= (struct print_options
*) data
;
720 struct plugin_name_args
*plugin
= (struct plugin_name_args
*) *slot
;
721 const char *help
= plugin
->help
? plugin
->help
: "No help available .";
723 char *dup
= xstrdup (help
);
725 fprintf (opt
->file
, " %s%s:\n", opt
->indent
, plugin
->base_name
);
727 for (p
= nl
= dup
; nl
; p
= nl
)
729 nl
= strchr (nl
, '\n');
735 fprintf (opt
->file
, " %s %s\n", opt
->indent
, p
);
742 /* Print help for each plugin. The output goes to FILE and every line starts
746 print_plugins_help (FILE *file
, const char *indent
)
748 struct print_options opt
;
751 if (!plugin_name_args_tab
|| htab_elements (plugin_name_args_tab
) == 0)
754 fprintf (file
, "%sHelp for the loaded plugins:\n", indent
);
755 htab_traverse_noresize (plugin_name_args_tab
, print_help_one_plugin
, &opt
);
759 /* Return true if plugins have been loaded. */
762 plugins_active_p (void)
764 enum plugin_event event
;
766 for (event
= PLUGIN_PASS_MANAGER_SETUP
; event
< PLUGIN_EVENT_LAST
; event
++)
767 if (plugin_callbacks
[event
])
774 /* Dump to FILE the names and associated events for all the active
778 dump_active_plugins (FILE *file
)
780 enum plugin_event event
;
782 if (!plugins_active_p ())
785 fprintf (stderr
, "Event\t\t\tPlugins\n");
786 for (event
= PLUGIN_PASS_MANAGER_SETUP
; event
< PLUGIN_EVENT_LAST
; event
++)
787 if (plugin_callbacks
[event
])
789 struct callback_info
*ci
;
791 fprintf (file
, "%s\t", plugin_event_name
[event
]);
793 for (ci
= plugin_callbacks
[event
]; ci
; ci
= ci
->next
)
794 fprintf (file
, "%s ", ci
->plugin_name
);
796 fprintf (file
, "\n");
801 /* Dump active plugins to stderr. */
804 debug_active_plugins (void)
806 dump_active_plugins (stderr
);