Branch data Line data Source code
1 : : /* Support for GCC plugin mechanism.
2 : : Copyright (C) 2009-2025 Free Software Foundation, Inc.
3 : :
4 : : This file is part of GCC.
5 : :
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.
10 : :
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.
15 : :
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/>. */
19 : :
20 : : /* This file contains the support for GCC plugin mechanism based on the
21 : : APIs described in doc/plugin.texi. */
22 : :
23 : : #include "config.h"
24 : : #define INCLUDE_DLFCN_H
25 : : #include "system.h"
26 : : #include "coretypes.h"
27 : : #include "options.h"
28 : : #include "tree-pass.h"
29 : : #include "diagnostic-core.h"
30 : : #include "flags.h"
31 : : #include "intl.h"
32 : : #include "plugin.h"
33 : :
34 : : #ifdef ENABLE_PLUGIN
35 : : #include "plugin-version.h"
36 : : #endif
37 : :
38 : : #ifdef __MINGW32__
39 : : #ifndef WIN32_LEAN_AND_MEAN
40 : : #define WIN32_LEAN_AND_MEAN
41 : : #endif
42 : : #ifndef NOMINMAX
43 : : #define NOMINMAX
44 : : #endif
45 : : #define WIN32_LEAN_AND_MEAN
46 : : #include <windows.h>
47 : : #endif
48 : :
49 : : #define GCC_PLUGIN_STRINGIFY0(X) #X
50 : : #define GCC_PLUGIN_STRINGIFY1(X) GCC_PLUGIN_STRINGIFY0 (X)
51 : :
52 : : /* Event names as strings. Keep in sync with enum plugin_event. */
53 : : static const char *plugin_event_name_init[] =
54 : : {
55 : : # define DEFEVENT(NAME) GCC_PLUGIN_STRINGIFY1 (NAME),
56 : : # include "plugin.def"
57 : : # undef DEFEVENT
58 : : };
59 : :
60 : : /* A printf format large enough for the largest event above. */
61 : : #define FMT_FOR_PLUGIN_EVENT "%-32s"
62 : :
63 : : const char **plugin_event_name = plugin_event_name_init;
64 : :
65 : : /* Event hashtable helpers. */
66 : :
67 : : struct event_hasher : nofree_ptr_hash <const char *>
68 : : {
69 : : static inline hashval_t hash (const char **);
70 : : static inline bool equal (const char **, const char **);
71 : : };
72 : :
73 : : /* Helper function for the event hash table that hashes the entry V. */
74 : :
75 : : inline hashval_t
76 : 0 : event_hasher::hash (const char **v)
77 : : {
78 : 0 : return htab_hash_string (*v);
79 : : }
80 : :
81 : : /* Helper function for the event hash table that compares the name of an
82 : : existing entry (S1) with the given string (S2). */
83 : :
84 : : inline bool
85 : 0 : event_hasher::equal (const char **s1, const char **s2)
86 : : {
87 : 0 : return !strcmp (*s1, *s2);
88 : : }
89 : :
90 : : /* A hash table to map event names to the position of the names in the
91 : : plugin_event_name table. */
92 : : static hash_table<event_hasher> *event_tab;
93 : :
94 : : /* Keep track of the limit of allocated events and space ready for
95 : : allocating events. */
96 : : static int event_last = PLUGIN_EVENT_FIRST_DYNAMIC;
97 : : static int event_horizon = PLUGIN_EVENT_FIRST_DYNAMIC;
98 : :
99 : : /* Hash table for the plugin_name_args objects created during command-line
100 : : parsing. */
101 : : static htab_t plugin_name_args_tab = NULL;
102 : :
103 : : /* List node for keeping track of plugin-registered callback. */
104 : : struct callback_info
105 : : {
106 : : const char *plugin_name; /* Name of plugin that registers the callback. */
107 : : plugin_callback_func func; /* Callback to be called. */
108 : : void *user_data; /* plugin-specified data. */
109 : : struct callback_info *next;
110 : : };
111 : :
112 : : /* An array of lists of 'callback_info' objects indexed by the event id. */
113 : : static struct callback_info *plugin_callbacks_init[PLUGIN_EVENT_FIRST_DYNAMIC];
114 : : static struct callback_info **plugin_callbacks = plugin_callbacks_init;
115 : :
116 : : /* For invoke_plugin_callbacks(), see plugin.h. */
117 : : bool flag_plugin_added = false;
118 : :
119 : : #ifdef ENABLE_PLUGIN
120 : : /* Each plugin should define an initialization function with exactly
121 : : this name. */
122 : : static const char *str_plugin_init_func_name = "plugin_init";
123 : :
124 : : /* Each plugin should define this symbol to assert that it is
125 : : distributed under a GPL-compatible license. */
126 : : static const char *str_license = "plugin_is_GPL_compatible";
127 : : #endif
128 : :
129 : : /* Helper function for hashing the base_name of the plugin_name_args
130 : : structure to be inserted into the hash table. */
131 : :
132 : : static hashval_t
133 : 0 : htab_hash_plugin (const void *p)
134 : : {
135 : 0 : const struct plugin_name_args *plugin = (const struct plugin_name_args *) p;
136 : 0 : return htab_hash_string (plugin->base_name);
137 : : }
138 : :
139 : : /* Helper function for the hash table that compares the base_name of the
140 : : existing entry (S1) with the given string (S2). */
141 : :
142 : : static int
143 : 12 : htab_str_eq (const void *s1, const void *s2)
144 : : {
145 : 12 : const struct plugin_name_args *plugin = (const struct plugin_name_args *) s1;
146 : 12 : return !strcmp (plugin->base_name, (const char *) s2);
147 : : }
148 : :
149 : :
150 : : /* Given a plugin's full-path name FULL_NAME, e.g. /pass/to/NAME.so,
151 : : return NAME. */
152 : :
153 : : static char *
154 : 136 : get_plugin_base_name (const char *full_name)
155 : : {
156 : : /* First get the base name part of the full-path name, i.e. NAME.so. */
157 : 136 : char *base_name = xstrdup (lbasename (full_name));
158 : :
159 : : /* Then get rid of the extension in the name, e.g., .so. */
160 : 136 : strip_off_ending (base_name, strlen (base_name));
161 : :
162 : 136 : return base_name;
163 : : }
164 : :
165 : :
166 : : /* Create a plugin_name_args object for the given plugin and insert it
167 : : to the hash table. This function is called when
168 : : -fplugin=/path/to/NAME.so or -fplugin=NAME option is processed. */
169 : :
170 : : void
171 : 246 : add_new_plugin (const char* plugin_name)
172 : : {
173 : 246 : struct plugin_name_args *plugin;
174 : 246 : void **slot;
175 : 246 : char *base_name;
176 : 246 : bool name_is_short;
177 : 246 : const char *pc;
178 : :
179 : 246 : flag_plugin_added = true;
180 : :
181 : : /* Replace short names by their full path when relevant. */
182 : 246 : name_is_short = !IS_ABSOLUTE_PATH (plugin_name);
183 : 924 : for (pc = plugin_name; name_is_short && *pc; pc++)
184 : 678 : if (*pc == '.' || IS_DIR_SEPARATOR (*pc))
185 : 136 : name_is_short = false;
186 : :
187 : 246 : if (name_is_short)
188 : : {
189 : 110 : base_name = CONST_CAST (char*, plugin_name);
190 : :
191 : : #if defined(__MINGW32__)
192 : : static const char plugin_ext[] = ".dll";
193 : : #elif defined(__APPLE__)
194 : : /* macOS has two types of libraries: dynamic libraries (.dylib) and
195 : : plugins (.bundle). Both can be used with dlopen()/dlsym() but the
196 : : former cannot be linked at build time (i.e., with the -lfoo linker
197 : : option). A GCC plugin is therefore probably a macOS plugin but their
198 : : use seems to be quite rare and the .bundle extension is more of a
199 : : recommendation rather than the rule. This raises the questions of how
200 : : well they are supported by tools (e.g., libtool). So to avoid
201 : : complications let's use the .dylib extension for now. In the future,
202 : : if this proves to be an issue, we can always check for both
203 : : extensions. */
204 : : static const char plugin_ext[] = ".dylib";
205 : : #else
206 : 110 : static const char plugin_ext[] = ".so";
207 : : #endif
208 : :
209 : 110 : plugin_name = concat (default_plugin_dir_name (), "/",
210 : : plugin_name, plugin_ext, NULL);
211 : 110 : if (access (plugin_name, R_OK))
212 : 4 : fatal_error
213 : 4 : (input_location,
214 : : "inaccessible plugin file %s expanded from short plugin name %s: %m",
215 : : plugin_name, base_name);
216 : : }
217 : : else
218 : 136 : base_name = get_plugin_base_name (plugin_name);
219 : :
220 : : /* If this is the first -fplugin= option we encounter, create
221 : : 'plugin_name_args_tab' hash table. */
222 : 242 : if (!plugin_name_args_tab)
223 : 242 : plugin_name_args_tab = htab_create (10, htab_hash_plugin, htab_str_eq,
224 : : NULL);
225 : :
226 : 242 : slot = htab_find_slot_with_hash (plugin_name_args_tab, base_name,
227 : : htab_hash_string (base_name), INSERT);
228 : :
229 : : /* If the same plugin (name) has been specified earlier, either emit an
230 : : error or a warning message depending on if they have identical full
231 : : (path) names. */
232 : 242 : if (*slot)
233 : : {
234 : 0 : plugin = (struct plugin_name_args *) *slot;
235 : 0 : if (strcmp (plugin->full_name, plugin_name))
236 : 0 : error ("plugin %qs was specified with different paths: %qs and %qs",
237 : : plugin->base_name, plugin->full_name, plugin_name);
238 : 0 : return;
239 : : }
240 : :
241 : 242 : plugin = XCNEW (struct plugin_name_args);
242 : 242 : plugin->base_name = base_name;
243 : 242 : plugin->full_name = plugin_name;
244 : :
245 : 242 : *slot = plugin;
246 : : }
247 : :
248 : :
249 : : /* Parse the -fplugin-arg-<name>-<key>[=<value>] option and create a
250 : : 'plugin_argument' object for the parsed key-value pair. ARG is
251 : : the <name>-<key>[=<value>] part of the option. */
252 : :
253 : : void
254 : 12 : parse_plugin_arg_opt (const char *arg)
255 : : {
256 : 12 : size_t len = 0, name_len = 0, key_len = 0, value_len = 0;
257 : 12 : const char *ptr, *name_start = arg, *key_start = NULL, *value_start = NULL;
258 : 12 : char *name, *key, *value;
259 : 12 : void **slot;
260 : 12 : bool name_parsed = false, key_parsed = false;
261 : :
262 : : /* Iterate over the ARG string and identify the starting character position
263 : : of 'name', 'key', and 'value' and their lengths. */
264 : 426 : for (ptr = arg; *ptr; ++ptr)
265 : : {
266 : : /* Only the first '-' encountered is considered a separator between
267 : : 'name' and 'key'. All the subsequent '-'s are considered part of
268 : : 'key'. For example, given -fplugin-arg-foo-bar-primary-key=value,
269 : : the plugin name is 'foo' and the key is 'bar-primary-key'. */
270 : 414 : if (*ptr == '-' && !name_parsed)
271 : : {
272 : 12 : name_len = len;
273 : 12 : len = 0;
274 : 12 : key_start = ptr + 1;
275 : 12 : name_parsed = true;
276 : 12 : continue;
277 : : }
278 : 402 : else if (*ptr == '=')
279 : : {
280 : 7 : if (!key_parsed)
281 : : {
282 : 7 : key_len = len;
283 : 7 : len = 0;
284 : 7 : value_start = ptr + 1;
285 : 7 : key_parsed = true;
286 : : }
287 : 7 : continue;
288 : : }
289 : : else
290 : 395 : ++len;
291 : : }
292 : :
293 : 12 : if (!key_start)
294 : : {
295 : 0 : error ("malformed option %<-fplugin-arg-%s%>: "
296 : : "missing %<-<key>[=<value>]%>",
297 : : arg);
298 : 0 : return;
299 : : }
300 : :
301 : : /* If the option doesn't contain the 'value' part, LEN is the KEY_LEN.
302 : : Otherwise, it is the VALUE_LEN. */
303 : 12 : if (!value_start)
304 : : key_len = len;
305 : : else
306 : 7 : value_len = len;
307 : :
308 : 12 : name = XNEWVEC (char, name_len + 1);
309 : 12 : strncpy (name, name_start, name_len);
310 : 12 : name[name_len] = '\0';
311 : :
312 : : /* Check if the named plugin has already been specified earlier in the
313 : : command-line. */
314 : 12 : if (plugin_name_args_tab
315 : 12 : && ((slot = htab_find_slot_with_hash (plugin_name_args_tab, name,
316 : : htab_hash_string (name), NO_INSERT))
317 : : != NULL))
318 : : {
319 : 12 : struct plugin_name_args *plugin = (struct plugin_name_args *) *slot;
320 : :
321 : 12 : key = XNEWVEC (char, key_len + 1);
322 : 12 : strncpy (key, key_start, key_len);
323 : 12 : key[key_len] = '\0';
324 : 12 : if (value_start)
325 : : {
326 : 7 : value = XNEWVEC (char, value_len + 1);
327 : 7 : strncpy (value, value_start, value_len);
328 : 7 : value[value_len] = '\0';
329 : : }
330 : : else
331 : : value = NULL;
332 : :
333 : : /* Create a plugin_argument object for the parsed key-value pair.
334 : : If there are already arguments for this plugin, we will need to
335 : : adjust the argument array size by creating a new array and deleting
336 : : the old one. If the performance ever becomes an issue, we can
337 : : change the code by pre-allocating a larger array first. */
338 : 12 : if (plugin->argc > 0)
339 : : {
340 : 1 : struct plugin_argument *args = XNEWVEC (struct plugin_argument,
341 : : plugin->argc + 1);
342 : 1 : memcpy (args, plugin->argv,
343 : 1 : sizeof (struct plugin_argument) * plugin->argc);
344 : 1 : XDELETEVEC (plugin->argv);
345 : 1 : plugin->argv = args;
346 : 1 : ++plugin->argc;
347 : : }
348 : : else
349 : : {
350 : 11 : gcc_assert (plugin->argv == NULL);
351 : 11 : plugin->argv = XNEWVEC (struct plugin_argument, 1);
352 : 11 : plugin->argc = 1;
353 : : }
354 : :
355 : 12 : plugin->argv[plugin->argc - 1].key = key;
356 : 12 : plugin->argv[plugin->argc - 1].value = value;
357 : : }
358 : : else
359 : 0 : error ("plugin %s should be specified before %<-fplugin-arg-%s%> "
360 : : "in the command line", name, arg);
361 : :
362 : : /* We don't need the plugin's name anymore. Just release it. */
363 : 12 : XDELETEVEC (name);
364 : : }
365 : :
366 : : /* Register additional plugin information. NAME is the name passed to
367 : : plugin_init. INFO is the information that should be registered. */
368 : :
369 : : static void
370 : 0 : register_plugin_info (const char* name, struct plugin_info *info)
371 : : {
372 : 0 : void **slot = htab_find_slot_with_hash (plugin_name_args_tab, name,
373 : : htab_hash_string (name), NO_INSERT);
374 : 0 : struct plugin_name_args *plugin;
375 : :
376 : 0 : if (slot == NULL)
377 : : {
378 : 0 : error ("unable to register info for plugin %qs - plugin name not found",
379 : : name);
380 : 0 : return;
381 : : }
382 : 0 : plugin = (struct plugin_name_args *) *slot;
383 : 0 : plugin->version = info->version;
384 : 0 : plugin->help = info->help;
385 : : }
386 : :
387 : : /* Look up the event id for NAME. If the name is not found, return -1
388 : : if INSERT is NO_INSERT. */
389 : :
390 : : int
391 : 0 : get_named_event_id (const char *name, enum insert_option insert)
392 : : {
393 : 0 : const char ***slot;
394 : :
395 : 0 : if (!event_tab)
396 : : {
397 : 0 : int i;
398 : :
399 : 0 : event_tab = new hash_table<event_hasher> (150);
400 : 0 : for (i = 0; i < event_last; i++)
401 : : {
402 : 0 : slot = event_tab->find_slot (&plugin_event_name[i], INSERT);
403 : 0 : gcc_assert (*slot == HTAB_EMPTY_ENTRY);
404 : 0 : *slot = &plugin_event_name[i];
405 : : }
406 : : }
407 : 0 : slot = event_tab->find_slot (&name, insert);
408 : 0 : if (slot == NULL)
409 : : return -1;
410 : 0 : if (*slot != HTAB_EMPTY_ENTRY)
411 : 0 : return *slot - &plugin_event_name[0];
412 : :
413 : 0 : if (event_last >= event_horizon)
414 : : {
415 : 0 : event_horizon = event_last * 2;
416 : 0 : if (plugin_event_name == plugin_event_name_init)
417 : : {
418 : 0 : plugin_event_name = XNEWVEC (const char *, event_horizon);
419 : 0 : memcpy (plugin_event_name, plugin_event_name_init,
420 : : sizeof plugin_event_name_init);
421 : 0 : plugin_callbacks = XNEWVEC (struct callback_info *, event_horizon);
422 : 0 : memcpy (plugin_callbacks, plugin_callbacks_init,
423 : : sizeof plugin_callbacks_init);
424 : : }
425 : : else
426 : : {
427 : 0 : plugin_event_name
428 : 0 : = XRESIZEVEC (const char *, plugin_event_name, event_horizon);
429 : 0 : plugin_callbacks = XRESIZEVEC (struct callback_info *,
430 : : plugin_callbacks, event_horizon);
431 : : }
432 : : /* All the pointers in the hash table will need to be updated. */
433 : 0 : delete event_tab;
434 : 0 : event_tab = NULL;
435 : : }
436 : : else
437 : 0 : *slot = &plugin_event_name[event_last];
438 : 0 : plugin_event_name[event_last] = name;
439 : 0 : return event_last++;
440 : : }
441 : :
442 : : /* Called from the plugin's initialization code. Register a single callback.
443 : : This function can be called multiple times.
444 : :
445 : : PLUGIN_NAME - display name for this plugin
446 : : EVENT - which event the callback is for
447 : : CALLBACK - the callback to be called at the event
448 : : USER_DATA - plugin-provided data */
449 : :
450 : : void
451 : 332 : register_callback (const char *plugin_name,
452 : : int event,
453 : : plugin_callback_func callback,
454 : : void *user_data)
455 : : {
456 : 332 : switch (event)
457 : : {
458 : 164 : case PLUGIN_PASS_MANAGER_SETUP:
459 : 164 : gcc_assert (!callback);
460 : 164 : register_pass ((struct register_pass_info *) user_data);
461 : 164 : break;
462 : 0 : case PLUGIN_INFO:
463 : 0 : gcc_assert (!callback);
464 : 0 : register_plugin_info (plugin_name, (struct plugin_info *) user_data);
465 : 0 : break;
466 : 1 : case PLUGIN_REGISTER_GGC_ROOTS:
467 : 1 : gcc_assert (!callback);
468 : 1 : ggc_register_root_tab ((const struct ggc_root_tab*) user_data);
469 : 1 : break;
470 : 0 : case PLUGIN_EVENT_FIRST_DYNAMIC:
471 : 0 : default:
472 : 0 : if (event < PLUGIN_EVENT_FIRST_DYNAMIC || event >= event_last)
473 : : {
474 : 0 : error ("unknown callback event registered by plugin %s",
475 : : plugin_name);
476 : 0 : return;
477 : : }
478 : : /* Fall through. */
479 : 167 : case PLUGIN_START_PARSE_FUNCTION:
480 : 167 : case PLUGIN_FINISH_PARSE_FUNCTION:
481 : 167 : case PLUGIN_FINISH_TYPE:
482 : 167 : case PLUGIN_FINISH_DECL:
483 : 167 : case PLUGIN_START_UNIT:
484 : 167 : case PLUGIN_FINISH_UNIT:
485 : 167 : case PLUGIN_PRE_GENERICIZE:
486 : 167 : case PLUGIN_GGC_START:
487 : 167 : case PLUGIN_GGC_MARKING:
488 : 167 : case PLUGIN_GGC_END:
489 : 167 : case PLUGIN_ATTRIBUTES:
490 : 167 : case PLUGIN_PRAGMAS:
491 : 167 : case PLUGIN_FINISH:
492 : 167 : case PLUGIN_ALL_PASSES_START:
493 : 167 : case PLUGIN_ALL_PASSES_END:
494 : 167 : case PLUGIN_ALL_IPA_PASSES_START:
495 : 167 : case PLUGIN_ALL_IPA_PASSES_END:
496 : 167 : case PLUGIN_OVERRIDE_GATE:
497 : 167 : case PLUGIN_PASS_EXECUTION:
498 : 167 : case PLUGIN_EARLY_GIMPLE_PASSES_START:
499 : 167 : case PLUGIN_EARLY_GIMPLE_PASSES_END:
500 : 167 : case PLUGIN_NEW_PASS:
501 : 167 : case PLUGIN_INCLUDE_FILE:
502 : 167 : case PLUGIN_ANALYZER_INIT:
503 : 167 : {
504 : 167 : struct callback_info *new_callback;
505 : 167 : if (!callback)
506 : : {
507 : 0 : error ("plugin %s registered a null callback function "
508 : 0 : "for event %s", plugin_name, plugin_event_name[event]);
509 : 0 : return;
510 : : }
511 : 167 : new_callback = XNEW (struct callback_info);
512 : 167 : new_callback->plugin_name = plugin_name;
513 : 167 : new_callback->func = callback;
514 : 167 : new_callback->user_data = user_data;
515 : 167 : new_callback->next = plugin_callbacks[event];
516 : 167 : plugin_callbacks[event] = new_callback;
517 : : }
518 : 167 : break;
519 : : }
520 : : }
521 : :
522 : : /* Remove a callback for EVENT which has been registered with for a plugin
523 : : PLUGIN_NAME. Return PLUGEVT_SUCCESS if a matching callback was
524 : : found & removed, PLUGEVT_NO_CALLBACK if the event does not have a matching
525 : : callback, and PLUGEVT_NO_SUCH_EVENT if EVENT is invalid. */
526 : : int
527 : 0 : unregister_callback (const char *plugin_name, int event)
528 : : {
529 : 0 : struct callback_info *callback, **cbp;
530 : :
531 : 0 : if (event >= event_last)
532 : : return PLUGEVT_NO_SUCH_EVENT;
533 : :
534 : 0 : for (cbp = &plugin_callbacks[event]; (callback = *cbp); cbp = &callback->next)
535 : 0 : if (strcmp (callback->plugin_name, plugin_name) == 0)
536 : : {
537 : 0 : *cbp = callback->next;
538 : 0 : return PLUGEVT_SUCCESS;
539 : : }
540 : : return PLUGEVT_NO_CALLBACK;
541 : : }
542 : :
543 : : /* Invoke all plugin callbacks registered with the specified event,
544 : : called from invoke_plugin_callbacks(). */
545 : :
546 : : int
547 : 337158 : invoke_plugin_callbacks_full (int event, void *gcc_data)
548 : : {
549 : 337158 : int retval = PLUGEVT_SUCCESS;
550 : :
551 : 337158 : timevar_push (TV_PLUGIN_RUN);
552 : :
553 : 337158 : switch (event)
554 : : {
555 : 0 : case PLUGIN_EVENT_FIRST_DYNAMIC:
556 : 0 : default:
557 : 0 : gcc_assert (event >= PLUGIN_EVENT_FIRST_DYNAMIC);
558 : 0 : gcc_assert (event < event_last);
559 : : /* Fall through. */
560 : 337158 : case PLUGIN_START_PARSE_FUNCTION:
561 : 337158 : case PLUGIN_FINISH_PARSE_FUNCTION:
562 : 337158 : case PLUGIN_FINISH_TYPE:
563 : 337158 : case PLUGIN_FINISH_DECL:
564 : 337158 : case PLUGIN_START_UNIT:
565 : 337158 : case PLUGIN_FINISH_UNIT:
566 : 337158 : case PLUGIN_PRE_GENERICIZE:
567 : 337158 : case PLUGIN_ATTRIBUTES:
568 : 337158 : case PLUGIN_PRAGMAS:
569 : 337158 : case PLUGIN_FINISH:
570 : 337158 : case PLUGIN_GGC_START:
571 : 337158 : case PLUGIN_GGC_MARKING:
572 : 337158 : case PLUGIN_GGC_END:
573 : 337158 : case PLUGIN_ALL_PASSES_START:
574 : 337158 : case PLUGIN_ALL_PASSES_END:
575 : 337158 : case PLUGIN_ALL_IPA_PASSES_START:
576 : 337158 : case PLUGIN_ALL_IPA_PASSES_END:
577 : 337158 : case PLUGIN_OVERRIDE_GATE:
578 : 337158 : case PLUGIN_PASS_EXECUTION:
579 : 337158 : case PLUGIN_EARLY_GIMPLE_PASSES_START:
580 : 337158 : case PLUGIN_EARLY_GIMPLE_PASSES_END:
581 : 337158 : case PLUGIN_NEW_PASS:
582 : 337158 : case PLUGIN_INCLUDE_FILE:
583 : 337158 : case PLUGIN_ANALYZER_INIT:
584 : 337158 : {
585 : : /* Iterate over every callback registered with this event and
586 : : call it. */
587 : 337158 : struct callback_info *callback = plugin_callbacks[event];
588 : :
589 : 337158 : if (!callback)
590 : 336871 : retval = PLUGEVT_NO_CALLBACK;
591 : 337445 : for ( ; callback; callback = callback->next)
592 : 287 : (*callback->func) (gcc_data, callback->user_data);
593 : : }
594 : 337158 : break;
595 : :
596 : 0 : case PLUGIN_PASS_MANAGER_SETUP:
597 : 0 : case PLUGIN_REGISTER_GGC_ROOTS:
598 : 0 : gcc_assert (false);
599 : : }
600 : :
601 : 337158 : timevar_pop (TV_PLUGIN_RUN);
602 : 337158 : return retval;
603 : : }
604 : :
605 : : #ifdef ENABLE_PLUGIN
606 : :
607 : : /* Try to initialize PLUGIN. Return true if successful. */
608 : :
609 : : #ifdef __MINGW32__
610 : :
611 : : // Return a message string for last error or NULL if unknown. Must be freed
612 : : // with LocalFree().
613 : : static inline char *
614 : : win32_error_msg ()
615 : : {
616 : : char *msg;
617 : : return FormatMessageA (FORMAT_MESSAGE_ALLOCATE_BUFFER |
618 : : FORMAT_MESSAGE_FROM_SYSTEM |
619 : : FORMAT_MESSAGE_IGNORE_INSERTS |
620 : : FORMAT_MESSAGE_MAX_WIDTH_MASK,
621 : : 0,
622 : : GetLastError (),
623 : : MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
624 : : (char*)&msg,
625 : : 0,
626 : : 0)
627 : : ? msg
628 : : : NULL;
629 : : }
630 : :
631 : : static bool
632 : : try_init_one_plugin (struct plugin_name_args *plugin)
633 : : {
634 : : HMODULE dl_handle;
635 : : plugin_init_func plugin_init;
636 : :
637 : : dl_handle = LoadLibrary (plugin->full_name);
638 : : if (!dl_handle)
639 : : {
640 : : char *err = win32_error_msg ();
641 : : error ("cannot load plugin %s\n%s", plugin->full_name, err);
642 : : LocalFree (err);
643 : : return false;
644 : : }
645 : :
646 : : /* Check the plugin license. Unlike the name suggests, GetProcAddress()
647 : : can be used for both functions and variables. */
648 : : if (GetProcAddress (dl_handle, str_license) == NULL)
649 : : {
650 : : char *err = win32_error_msg ();
651 : : fatal_error (input_location,
652 : : "plugin %s is not licensed under a GPL-compatible license\n"
653 : : "%s", plugin->full_name, err);
654 : : }
655 : :
656 : : /* Unlike dlsym(), GetProcAddress() returns a pointer to a function so we
657 : : can cast directly without union tricks. */
658 : : plugin_init = (plugin_init_func)
659 : : GetProcAddress (dl_handle, str_plugin_init_func_name);
660 : :
661 : : if (plugin_init == NULL)
662 : : {
663 : : char *err = win32_error_msg ();
664 : : FreeLibrary (dl_handle);
665 : : error ("cannot find %s in plugin %s\n%s", str_plugin_init_func_name,
666 : : plugin->full_name, err);
667 : : LocalFree (err);
668 : : return false;
669 : : }
670 : :
671 : : /* Call the plugin-provided initialization routine with the arguments. */
672 : : if ((*plugin_init) (plugin, &gcc_version))
673 : : {
674 : : FreeLibrary (dl_handle);
675 : : error ("fail to initialize plugin %s", plugin->full_name);
676 : : return false;
677 : : }
678 : : /* Leak dl_handle on purpose to ensure the plugin is loaded for the
679 : : entire run of the compiler. */
680 : : return true;
681 : : }
682 : :
683 : : #else // POSIX-like with dlopen()/dlsym().
684 : :
685 : : /* We need a union to cast dlsym return value to a function pointer
686 : : as ISO C forbids assignment between function pointer and 'void *'.
687 : : Use explicit union instead of __extension__(<union_cast>) for
688 : : portability. */
689 : : #define PTR_UNION_TYPE(TOTYPE) union { void *_q; TOTYPE _nq; }
690 : : #define PTR_UNION_AS_VOID_PTR(NAME) (NAME._q)
691 : : #define PTR_UNION_AS_CAST_PTR(NAME) (NAME._nq)
692 : :
693 : : static bool
694 : 242 : try_init_one_plugin (struct plugin_name_args *plugin)
695 : : {
696 : 242 : void *dl_handle;
697 : 242 : plugin_init_func plugin_init;
698 : 242 : const char *err;
699 : 242 : PTR_UNION_TYPE (plugin_init_func) plugin_init_union;
700 : :
701 : : /* We use RTLD_NOW to accelerate binding and detect any mismatch
702 : : between the API expected by the plugin and the GCC API; we use
703 : : RTLD_GLOBAL which is useful to plugins which themselves call
704 : : dlopen. */
705 : 242 : dl_handle = dlopen (plugin->full_name, RTLD_NOW | RTLD_GLOBAL);
706 : 242 : if (!dl_handle)
707 : : {
708 : 0 : error ("cannot load plugin %s: %s", plugin->full_name, dlerror ());
709 : 0 : return false;
710 : : }
711 : :
712 : : /* Clear any existing error. */
713 : 242 : dlerror ();
714 : :
715 : : /* Check the plugin license. */
716 : 242 : if (dlsym (dl_handle, str_license) == NULL)
717 : 0 : fatal_error (input_location,
718 : : "plugin %s is not licensed under a GPL-compatible license:"
719 : : " %s", plugin->full_name, dlerror ());
720 : :
721 : 242 : PTR_UNION_AS_VOID_PTR (plugin_init_union)
722 : 242 : = dlsym (dl_handle, str_plugin_init_func_name);
723 : 242 : plugin_init = PTR_UNION_AS_CAST_PTR (plugin_init_union);
724 : :
725 : 242 : if ((err = dlerror ()) != NULL)
726 : : {
727 : 0 : dlclose(dl_handle);
728 : 0 : error ("cannot find %s in plugin %s: %s", str_plugin_init_func_name,
729 : : plugin->full_name, err);
730 : 0 : return false;
731 : : }
732 : :
733 : : /* Call the plugin-provided initialization routine with the arguments. */
734 : 242 : if ((*plugin_init) (plugin, &gcc_version))
735 : : {
736 : 0 : dlclose(dl_handle);
737 : 0 : error ("failed to initialize plugin %s", plugin->full_name);
738 : 0 : return false;
739 : : }
740 : : /* leak dl_handle on purpose to ensure the plugin is loaded for the
741 : : entire run of the compiler. */
742 : : return true;
743 : : }
744 : : #endif
745 : :
746 : : /* Routine to dlopen and initialize one plugin. This function is passed to
747 : : (and called by) the hash table traverse routine. Return 1 for the
748 : : htab_traverse to continue scan, 0 to stop.
749 : :
750 : : SLOT - slot of the hash table element
751 : : INFO - auxiliary pointer handed to hash table traverse routine
752 : : (unused in this function) */
753 : :
754 : : static int
755 : 242 : init_one_plugin (void **slot, void * ARG_UNUSED (info))
756 : : {
757 : 242 : struct plugin_name_args *plugin = (struct plugin_name_args *) *slot;
758 : 242 : bool ok = try_init_one_plugin (plugin);
759 : 242 : if (!ok)
760 : : {
761 : 0 : htab_remove_elt_with_hash (plugin_name_args_tab, plugin->base_name,
762 : 0 : htab_hash_string (plugin->base_name));
763 : 0 : XDELETE (plugin);
764 : : }
765 : 242 : return 1;
766 : : }
767 : :
768 : : #endif /* ENABLE_PLUGIN */
769 : :
770 : : /* Main plugin initialization function. Called from compile_file() in
771 : : toplev.cc. */
772 : :
773 : : void
774 : 277913 : initialize_plugins (void)
775 : : {
776 : : /* If no plugin was specified in the command-line, simply return. */
777 : 277913 : if (!plugin_name_args_tab)
778 : : return;
779 : :
780 : 242 : timevar_push (TV_PLUGIN_INIT);
781 : :
782 : : #ifdef ENABLE_PLUGIN
783 : : /* Traverse and initialize each plugin specified in the command-line. */
784 : 242 : htab_traverse_noresize (plugin_name_args_tab, init_one_plugin, NULL);
785 : : #endif
786 : :
787 : 242 : timevar_pop (TV_PLUGIN_INIT);
788 : : }
789 : :
790 : : /* Release memory used by one plugin. */
791 : :
792 : : static int
793 : 232 : finalize_one_plugin (void **slot, void * ARG_UNUSED (info))
794 : : {
795 : 232 : struct plugin_name_args *plugin = (struct plugin_name_args *) *slot;
796 : 232 : XDELETE (plugin);
797 : 232 : return 1;
798 : : }
799 : :
800 : : /* Free memory allocated by the plugin system. */
801 : :
802 : : void
803 : 276016 : finalize_plugins (void)
804 : : {
805 : 276016 : if (!plugin_name_args_tab)
806 : : return;
807 : :
808 : : /* We can now delete the plugin_name_args object as it will no longer
809 : : be used. Note that base_name and argv fields (both of which were also
810 : : dynamically allocated) are not freed as they could still be used by
811 : : the plugin code. */
812 : :
813 : 232 : htab_traverse_noresize (plugin_name_args_tab, finalize_one_plugin, NULL);
814 : :
815 : : /* PLUGIN_NAME_ARGS_TAB is no longer needed, just delete it. */
816 : 232 : htab_delete (plugin_name_args_tab);
817 : 232 : plugin_name_args_tab = NULL;
818 : : }
819 : :
820 : : /* Implementation detail of for_each_plugin. */
821 : :
822 : : struct for_each_plugin_closure
823 : : {
824 : : void (*cb) (const plugin_name_args *,
825 : : void *user_data);
826 : : void *user_data;
827 : : };
828 : :
829 : : /* Implementation detail of for_each_plugin: callback for htab_traverse_noresize
830 : : that calls the user-provided callback. */
831 : :
832 : : static int
833 : 8 : for_each_plugin_cb (void **slot, void *info)
834 : : {
835 : 8 : struct plugin_name_args *plugin = (struct plugin_name_args *) *slot;
836 : 8 : for_each_plugin_closure *c = (for_each_plugin_closure *)info;
837 : 8 : c->cb (plugin, c->user_data);
838 : 8 : return 1;
839 : : }
840 : :
841 : : /* Call CB with USER_DATA on each plugin. */
842 : :
843 : : void
844 : 92 : for_each_plugin (void (*cb) (const plugin_name_args *,
845 : : void *user_data),
846 : : void *user_data)
847 : : {
848 : 92 : if (!plugin_name_args_tab)
849 : 84 : return;
850 : :
851 : 8 : for_each_plugin_closure c;
852 : 8 : c.cb = cb;
853 : 8 : c.user_data = user_data;
854 : :
855 : 8 : htab_traverse_noresize (plugin_name_args_tab, for_each_plugin_cb, &c);
856 : : }
857 : :
858 : : /* Used to pass options to htab_traverse callbacks. */
859 : :
860 : : struct print_options
861 : : {
862 : : FILE *file;
863 : : const char *indent;
864 : : };
865 : :
866 : : /* Print the version of one plugin. */
867 : :
868 : : static int
869 : 0 : print_version_one_plugin (void **slot, void *data)
870 : : {
871 : 0 : struct print_options *opt = (struct print_options *) data;
872 : 0 : struct plugin_name_args *plugin = (struct plugin_name_args *) *slot;
873 : 0 : const char *version = plugin->version ? plugin->version : "Unknown version.";
874 : :
875 : 0 : fprintf (opt->file, " %s%s: %s\n", opt->indent, plugin->base_name, version);
876 : 0 : return 1;
877 : : }
878 : :
879 : : /* Print the version of each plugin. */
880 : :
881 : : void
882 : 123 : print_plugins_versions (FILE *file, const char *indent)
883 : : {
884 : 123 : struct print_options opt;
885 : 123 : opt.file = file;
886 : 123 : opt.indent = indent;
887 : 123 : if (!plugin_name_args_tab || htab_elements (plugin_name_args_tab) == 0)
888 : 123 : return;
889 : :
890 : 0 : fprintf (file, "%sVersions of loaded plugins:\n", indent);
891 : 0 : htab_traverse_noresize (plugin_name_args_tab, print_version_one_plugin, &opt);
892 : : }
893 : :
894 : : /* Print help for one plugin. SLOT is the hash table slot. DATA is the
895 : : argument to htab_traverse_noresize. */
896 : :
897 : : static int
898 : 0 : print_help_one_plugin (void **slot, void *data)
899 : : {
900 : 0 : struct print_options *opt = (struct print_options *) data;
901 : 0 : struct plugin_name_args *plugin = (struct plugin_name_args *) *slot;
902 : 0 : const char *help = plugin->help ? plugin->help : "No help available .";
903 : :
904 : 0 : char *dup = xstrdup (help);
905 : 0 : char *p, *nl;
906 : 0 : fprintf (opt->file, " %s%s:\n", opt->indent, plugin->base_name);
907 : :
908 : 0 : for (p = nl = dup; nl; p = nl)
909 : : {
910 : 0 : nl = strchr (nl, '\n');
911 : 0 : if (nl)
912 : : {
913 : 0 : *nl = '\0';
914 : 0 : nl++;
915 : : }
916 : 0 : fprintf (opt->file, " %s %s\n", opt->indent, p);
917 : : }
918 : :
919 : 0 : free (dup);
920 : 0 : return 1;
921 : : }
922 : :
923 : : /* Print help for each plugin. The output goes to FILE and every line starts
924 : : with INDENT. */
925 : :
926 : : void
927 : 3 : print_plugins_help (FILE *file, const char *indent)
928 : : {
929 : 3 : struct print_options opt;
930 : 3 : opt.file = file;
931 : 3 : opt.indent = indent;
932 : 3 : if (!plugin_name_args_tab || htab_elements (plugin_name_args_tab) == 0)
933 : 3 : return;
934 : :
935 : 0 : fprintf (file, "%sHelp for the loaded plugins:\n", indent);
936 : 0 : htab_traverse_noresize (plugin_name_args_tab, print_help_one_plugin, &opt);
937 : : }
938 : :
939 : :
940 : : /* Return true if plugins have been loaded. */
941 : :
942 : : bool
943 : 24 : plugins_active_p (void)
944 : : {
945 : 24 : int event;
946 : :
947 : 624 : for (event = PLUGIN_PASS_MANAGER_SETUP; event < event_last; event++)
948 : 600 : if (plugin_callbacks[event])
949 : : return true;
950 : :
951 : : return false;
952 : : }
953 : :
954 : :
955 : : /* Dump to FILE the names and associated events for all the active
956 : : plugins. */
957 : :
958 : : DEBUG_FUNCTION void
959 : 0 : dump_active_plugins (FILE *file)
960 : : {
961 : 0 : int event;
962 : :
963 : 0 : if (!plugins_active_p ())
964 : : return;
965 : :
966 : 0 : fprintf (file, FMT_FOR_PLUGIN_EVENT " | %s\n", _("Event"), _("Plugins"));
967 : 0 : for (event = PLUGIN_PASS_MANAGER_SETUP; event < event_last; event++)
968 : 0 : if (plugin_callbacks[event])
969 : : {
970 : 0 : struct callback_info *ci;
971 : :
972 : 0 : fprintf (file, FMT_FOR_PLUGIN_EVENT " |", plugin_event_name[event]);
973 : :
974 : 0 : for (ci = plugin_callbacks[event]; ci; ci = ci->next)
975 : 0 : fprintf (file, " %s", ci->plugin_name);
976 : :
977 : 0 : putc ('\n', file);
978 : : }
979 : : }
980 : :
981 : :
982 : : /* Dump active plugins to stderr. */
983 : :
984 : : DEBUG_FUNCTION void
985 : 0 : debug_active_plugins (void)
986 : : {
987 : 0 : dump_active_plugins (stderr);
988 : 0 : }
989 : :
990 : : /* Give a warning if plugins are present, before an ICE message asking
991 : : to submit a bug report. */
992 : :
993 : : void
994 : 24 : warn_if_plugins (void)
995 : : {
996 : 24 : if (plugins_active_p ())
997 : : {
998 : 0 : fnotice (stderr, "*** WARNING *** there are active plugins, do not report"
999 : : " this as a bug unless you can reproduce it without enabling"
1000 : : " any plugins.\n");
1001 : 0 : dump_active_plugins (stderr);
1002 : : }
1003 : :
1004 : 24 : }
1005 : :
1006 : : /* The default version check. Compares every field in VERSION. */
1007 : :
1008 : : bool
1009 : 180 : plugin_default_version_check (struct plugin_gcc_version *gcc_version,
1010 : : struct plugin_gcc_version *plugin_version)
1011 : : {
1012 : 180 : if (!gcc_version || !plugin_version)
1013 : : return false;
1014 : :
1015 : 180 : if (strcmp (gcc_version->basever, plugin_version->basever))
1016 : : return false;
1017 : 180 : if (strcmp (gcc_version->datestamp, plugin_version->datestamp))
1018 : : return false;
1019 : 180 : if (strcmp (gcc_version->devphase, plugin_version->devphase))
1020 : : return false;
1021 : 180 : if (strcmp (gcc_version->revision, plugin_version->revision))
1022 : : return false;
1023 : 180 : if (strcmp (gcc_version->configuration_arguments,
1024 : : plugin_version->configuration_arguments))
1025 : 0 : return false;
1026 : : return true;
1027 : : }
1028 : :
1029 : :
1030 : : /* Return the current value of event_last, so that plugins which provide
1031 : : additional functionality for events for the benefit of high-level plugins
1032 : : know how many valid entries plugin_event_name holds. */
1033 : :
1034 : : int
1035 : 0 : get_event_last (void)
1036 : : {
1037 : 0 : return event_last;
1038 : : }
1039 : :
1040 : :
1041 : : /* Retrieve the default plugin directory. The gcc driver should have passed
1042 : : it as -iplugindir <dir> to the cc1 program, and it is queriable through the
1043 : : -print-file-name=plugin option to gcc. */
1044 : : const char*
1045 : 110 : default_plugin_dir_name (void)
1046 : : {
1047 : 110 : if (!plugindir_string)
1048 : 0 : fatal_error (input_location,
1049 : : "%<-iplugindir%> option not passed from the gcc driver");
1050 : 110 : return plugindir_string;
1051 : : }
|
