1/* Support for GCC plugin mechanism. 2 Copyright (C) 2009-2015 Free Software Foundation, Inc. 3 4This file is part of GCC. 5 6GCC is free software; you can redistribute it and/or modify 7it under the terms of the GNU General Public License as published by 8the Free Software Foundation; either version 3, or (at your option) 9any later version. 10 11GCC is distributed in the hope that it will be useful, 12but WITHOUT ANY WARRANTY; without even the implied warranty of 13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14GNU General Public License for more details. 15 16You should have received a copy of the GNU General Public License 17along 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#include "system.h" 25#include "coretypes.h" 26#include "hash-table.h" 27#include "diagnostic-core.h" 28#include "hash-set.h" 29#include "machmode.h" 30#include "vec.h" 31#include "double-int.h" 32#include "input.h" 33#include "alias.h" 34#include "symtab.h" 35#include "options.h" 36#include "flags.h" 37#include "wide-int.h" 38#include "inchash.h" 39#include "tree.h" 40#include "tree-pass.h" 41#include "intl.h" 42#include "plugin.h" 43#include "ggc.h" 44 45#ifdef ENABLE_PLUGIN 46#include "plugin-version.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. */ 53static 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 63const char **plugin_event_name = plugin_event_name_init; 64 65/* Event hashtable helpers. */ 66 67struct event_hasher : typed_noop_remove <const char *> 68{ 69 typedef const char *value_type; 70 typedef const char *compare_type; 71 static inline hashval_t hash (const value_type *); 72 static inline bool equal (const value_type *, const compare_type *); 73}; 74 75/* Helper function for the event hash table that hashes the entry V. */ 76 77inline hashval_t 78event_hasher::hash (const value_type *v) 79{ 80 return htab_hash_string (*v); 81} 82 83/* Helper function for the event hash table that compares the name of an 84 existing entry (S1) with the given string (S2). */ 85 86inline bool 87event_hasher::equal (const value_type *s1, const compare_type *s2) 88{ 89 return !strcmp (*s1, *s2); 90} 91 92/* A hash table to map event names to the position of the names in the 93 plugin_event_name table. */ 94static hash_table<event_hasher> *event_tab; 95 96/* Keep track of the limit of allocated events and space ready for 97 allocating events. */ 98static int event_last = PLUGIN_EVENT_FIRST_DYNAMIC; 99static int event_horizon = PLUGIN_EVENT_FIRST_DYNAMIC; 100 101/* Hash table for the plugin_name_args objects created during command-line 102 parsing. */ 103static htab_t plugin_name_args_tab = NULL; 104 105/* List node for keeping track of plugin-registered callback. */ 106struct callback_info 107{ 108 const char *plugin_name; /* Name of plugin that registers the callback. */ 109 plugin_callback_func func; /* Callback to be called. */ 110 void *user_data; /* plugin-specified data. */ 111 struct callback_info *next; 112}; 113 114/* An array of lists of 'callback_info' objects indexed by the event id. */ 115static struct callback_info *plugin_callbacks_init[PLUGIN_EVENT_FIRST_DYNAMIC]; 116static struct callback_info **plugin_callbacks = plugin_callbacks_init; 117 118/* For invoke_plugin_callbacks(), see plugin.h. */ 119bool flag_plugin_added = false; 120 121#ifdef ENABLE_PLUGIN 122/* Each plugin should define an initialization function with exactly 123 this name. */ 124static const char *str_plugin_init_func_name = "plugin_init"; 125 126/* Each plugin should define this symbol to assert that it is 127 distributed under a GPL-compatible license. */ 128static const char *str_license = "plugin_is_GPL_compatible"; 129#endif 130 131/* Helper function for the hash table that compares the base_name of the 132 existing entry (S1) with the given string (S2). */ 133 134static int 135htab_str_eq (const void *s1, const void *s2) 136{ 137 const struct plugin_name_args *plugin = (const struct plugin_name_args *) s1; 138 return !strcmp (plugin->base_name, (const char *) s2); 139} 140 141 142/* Given a plugin's full-path name FULL_NAME, e.g. /pass/to/NAME.so, 143 return NAME. */ 144 145static char * 146get_plugin_base_name (const char *full_name) 147{ 148 /* First get the base name part of the full-path name, i.e. NAME.so. */ 149 char *base_name = xstrdup (lbasename (full_name)); 150 151 /* Then get rid of '.so' part of the name. */ 152 strip_off_ending (base_name, strlen (base_name)); 153 154 return base_name; 155} 156 157 158/* Create a plugin_name_args object for the given plugin and insert it 159 to the hash table. This function is called when 160 -fplugin=/path/to/NAME.so or -fplugin=NAME option is processed. */ 161 162void 163add_new_plugin (const char* plugin_name) 164{ 165 struct plugin_name_args *plugin; 166 void **slot; 167 char *base_name; 168 bool name_is_short; 169 const char *pc; 170 171 flag_plugin_added = true; 172 173 /* Replace short names by their full path when relevant. */ 174 name_is_short = !IS_ABSOLUTE_PATH (plugin_name); 175 for (pc = plugin_name; name_is_short && *pc; pc++) 176 if (*pc == '.' || IS_DIR_SEPARATOR (*pc)) 177 name_is_short = false; 178 179 if (name_is_short) 180 { 181 base_name = CONST_CAST (char*, plugin_name); 182 /* FIXME: the ".so" suffix is currently builtin, since plugins 183 only work on ELF host systems like e.g. Linux or Solaris. 184 When plugins shall be available on non ELF systems such as 185 Windows or MacOS, this code has to be greatly improved. */ 186 plugin_name = concat (default_plugin_dir_name (), "/", 187 plugin_name, ".so", NULL); 188 if (access (plugin_name, R_OK)) 189 fatal_error 190 (input_location, 191 "inaccessible plugin file %s expanded from short plugin name %s: %m", 192 plugin_name, base_name); 193 } 194 else 195 base_name = get_plugin_base_name (plugin_name); 196 197 /* If this is the first -fplugin= option we encounter, create 198 'plugin_name_args_tab' hash table. */ 199 if (!plugin_name_args_tab) 200 plugin_name_args_tab = htab_create (10, htab_hash_string, htab_str_eq, 201 NULL); 202 203 slot = htab_find_slot (plugin_name_args_tab, base_name, INSERT); 204 205 /* If the same plugin (name) has been specified earlier, either emit an 206 error or a warning message depending on if they have identical full 207 (path) names. */ 208 if (*slot) 209 { 210 plugin = (struct plugin_name_args *) *slot; 211 if (strcmp (plugin->full_name, plugin_name)) 212 error ("plugin %s was specified with different paths:\n%s\n%s", 213 plugin->base_name, plugin->full_name, plugin_name); 214 return; 215 } 216 217 plugin = XCNEW (struct plugin_name_args); 218 plugin->base_name = base_name; 219 plugin->full_name = plugin_name; 220 221 *slot = plugin; 222} 223 224 225/* Parse the -fplugin-arg-<name>-<key>[=<value>] option and create a 226 'plugin_argument' object for the parsed key-value pair. ARG is 227 the <name>-<key>[=<value>] part of the option. */ 228 229void 230parse_plugin_arg_opt (const char *arg) 231{ 232 size_t len = 0, name_len = 0, key_len = 0, value_len = 0; 233 const char *ptr, *name_start = arg, *key_start = NULL, *value_start = NULL; 234 char *name, *key, *value; 235 void **slot; 236 bool name_parsed = false, key_parsed = false; 237 238 /* Iterate over the ARG string and identify the starting character position 239 of 'name', 'key', and 'value' and their lengths. */ 240 for (ptr = arg; *ptr; ++ptr) 241 { 242 /* Only the first '-' encountered is considered a separator between 243 'name' and 'key'. All the subsequent '-'s are considered part of 244 'key'. For example, given -fplugin-arg-foo-bar-primary-key=value, 245 the plugin name is 'foo' and the key is 'bar-primary-key'. */ 246 if (*ptr == '-' && !name_parsed) 247 { 248 name_len = len; 249 len = 0; 250 key_start = ptr + 1; 251 name_parsed = true; 252 continue; 253 } 254 else if (*ptr == '=') 255 { 256 if (!key_parsed) 257 { 258 key_len = len; 259 len = 0; 260 value_start = ptr + 1; 261 key_parsed = true; 262 } 263 continue; 264 } 265 else 266 ++len; 267 } 268 269 if (!key_start) 270 { 271 error ("malformed option -fplugin-arg-%s (missing -<key>[=<value>])", 272 arg); 273 return; 274 } 275 276 /* If the option doesn't contain the 'value' part, LEN is the KEY_LEN. 277 Otherwise, it is the VALUE_LEN. */ 278 if (!value_start) 279 key_len = len; 280 else 281 value_len = len; 282 283 name = XNEWVEC (char, name_len + 1); 284 strncpy (name, name_start, name_len); 285 name[name_len] = '\0'; 286 287 /* Check if the named plugin has already been specified earlier in the 288 command-line. */ 289 if (plugin_name_args_tab 290 && ((slot = htab_find_slot (plugin_name_args_tab, name, NO_INSERT)) 291 != NULL)) 292 { 293 struct plugin_name_args *plugin = (struct plugin_name_args *) *slot; 294 295 key = XNEWVEC (char, key_len + 1); 296 strncpy (key, key_start, key_len); 297 key[key_len] = '\0'; 298 if (value_start) 299 { 300 value = XNEWVEC (char, value_len + 1); 301 strncpy (value, value_start, value_len); 302 value[value_len] = '\0'; 303 } 304 else 305 value = NULL; 306 307 /* Create a plugin_argument object for the parsed key-value pair. 308 If there are already arguments for this plugin, we will need to 309 adjust the argument array size by creating a new array and deleting 310 the old one. If the performance ever becomes an issue, we can 311 change the code by pre-allocating a larger array first. */ 312 if (plugin->argc > 0) 313 { 314 struct plugin_argument *args = XNEWVEC (struct plugin_argument, 315 plugin->argc + 1); 316 memcpy (args, plugin->argv, 317 sizeof (struct plugin_argument) * plugin->argc); 318 XDELETEVEC (plugin->argv); 319 plugin->argv = args; 320 ++plugin->argc; 321 } 322 else 323 { 324 gcc_assert (plugin->argv == NULL); 325 plugin->argv = XNEWVEC (struct plugin_argument, 1); 326 plugin->argc = 1; 327 } 328 329 plugin->argv[plugin->argc - 1].key = key; 330 plugin->argv[plugin->argc - 1].value = value; 331 } 332 else 333 error ("plugin %s should be specified before -fplugin-arg-%s " 334 "in the command line", name, arg); 335 336 /* We don't need the plugin's name anymore. Just release it. */ 337 XDELETEVEC (name); 338} 339 340/* Register additional plugin information. NAME is the name passed to 341 plugin_init. INFO is the information that should be registered. */ 342 343static void 344register_plugin_info (const char* name, struct plugin_info *info) 345{ 346 void **slot = htab_find_slot (plugin_name_args_tab, name, NO_INSERT); 347 struct plugin_name_args *plugin = (struct plugin_name_args *) *slot; 348 plugin->version = info->version; 349 plugin->help = info->help; 350} 351 352/* Look up the event id for NAME. If the name is not found, return -1 353 if INSERT is NO_INSERT. */ 354 355int 356get_named_event_id (const char *name, enum insert_option insert) 357{ 358 const char ***slot; 359 360 if (!event_tab) 361 { 362 int i; 363 364 event_tab = new hash_table<event_hasher> (150); 365 for (i = 0; i < event_last; i++) 366 { 367 slot = event_tab->find_slot (&plugin_event_name[i], INSERT); 368 gcc_assert (*slot == HTAB_EMPTY_ENTRY); 369 *slot = &plugin_event_name[i]; 370 } 371 } 372 slot = event_tab->find_slot (&name, insert); 373 if (slot == NULL) 374 return -1; 375 if (*slot != HTAB_EMPTY_ENTRY) 376 return *slot - &plugin_event_name[0]; 377 378 if (event_last >= event_horizon) 379 { 380 event_horizon = event_last * 2; 381 if (plugin_event_name == plugin_event_name_init) 382 { 383 plugin_event_name = XNEWVEC (const char *, event_horizon); 384 memcpy (plugin_event_name, plugin_event_name_init, 385 sizeof plugin_event_name_init); 386 plugin_callbacks = XNEWVEC (struct callback_info *, event_horizon); 387 memcpy (plugin_callbacks, plugin_callbacks_init, 388 sizeof plugin_callbacks_init); 389 } 390 else 391 { 392 plugin_event_name 393 = XRESIZEVEC (const char *, plugin_event_name, event_horizon); 394 plugin_callbacks = XRESIZEVEC (struct callback_info *, 395 plugin_callbacks, event_horizon); 396 } 397 /* All the pointers in the hash table will need to be updated. */ 398 delete event_tab; 399 event_tab = NULL; 400 } 401 else 402 *slot = &plugin_event_name[event_last]; 403 plugin_event_name[event_last] = name; 404 return event_last++; 405} 406 407/* Called from the plugin's initialization code. Register a single callback. 408 This function can be called multiple times. 409 410 PLUGIN_NAME - display name for this plugin 411 EVENT - which event the callback is for 412 CALLBACK - the callback to be called at the event 413 USER_DATA - plugin-provided data */ 414 415void 416register_callback (const char *plugin_name, 417 int event, 418 plugin_callback_func callback, 419 void *user_data) 420{ 421 switch (event) 422 { 423 case PLUGIN_PASS_MANAGER_SETUP: 424 gcc_assert (!callback); 425 register_pass ((struct register_pass_info *) user_data); 426 break; 427 case PLUGIN_INFO: 428 gcc_assert (!callback); 429 register_plugin_info (plugin_name, (struct plugin_info *) user_data); 430 break; 431 case PLUGIN_REGISTER_GGC_ROOTS: 432 gcc_assert (!callback); 433 ggc_register_root_tab ((const struct ggc_root_tab*) user_data); 434 break; 435 case PLUGIN_EVENT_FIRST_DYNAMIC: 436 default: 437 if (event < PLUGIN_EVENT_FIRST_DYNAMIC || event >= event_last) 438 { 439 error ("unknown callback event registered by plugin %s", 440 plugin_name); 441 return; 442 } 443 /* Fall through. */ 444 case PLUGIN_FINISH_TYPE: 445 case PLUGIN_FINISH_DECL: 446 case PLUGIN_START_UNIT: 447 case PLUGIN_FINISH_UNIT: 448 case PLUGIN_PRE_GENERICIZE: 449 case PLUGIN_GGC_START: 450 case PLUGIN_GGC_MARKING: 451 case PLUGIN_GGC_END: 452 case PLUGIN_ATTRIBUTES: 453 case PLUGIN_PRAGMAS: 454 case PLUGIN_FINISH: 455 case PLUGIN_ALL_PASSES_START: 456 case PLUGIN_ALL_PASSES_END: 457 case PLUGIN_ALL_IPA_PASSES_START: 458 case PLUGIN_ALL_IPA_PASSES_END: 459 case PLUGIN_OVERRIDE_GATE: 460 case PLUGIN_PASS_EXECUTION: 461 case PLUGIN_EARLY_GIMPLE_PASSES_START: 462 case PLUGIN_EARLY_GIMPLE_PASSES_END: 463 case PLUGIN_NEW_PASS: 464 case PLUGIN_INCLUDE_FILE: 465 { 466 struct callback_info *new_callback; 467 if (!callback) 468 { 469 error ("plugin %s registered a null callback function " 470 "for event %s", plugin_name, plugin_event_name[event]); 471 return; 472 } 473 new_callback = XNEW (struct callback_info); 474 new_callback->plugin_name = plugin_name; 475 new_callback->func = callback; 476 new_callback->user_data = user_data; 477 new_callback->next = plugin_callbacks[event]; 478 plugin_callbacks[event] = new_callback; 479 } 480 break; 481 } 482} 483 484/* Remove a callback for EVENT which has been registered with for a plugin 485 PLUGIN_NAME. Return PLUGEVT_SUCCESS if a matching callback was 486 found & removed, PLUGEVT_NO_CALLBACK if the event does not have a matching 487 callback, and PLUGEVT_NO_SUCH_EVENT if EVENT is invalid. */ 488int 489unregister_callback (const char *plugin_name, int event) 490{ 491 struct callback_info *callback, **cbp; 492 493 if (event >= event_last) 494 return PLUGEVT_NO_SUCH_EVENT; 495 496 for (cbp = &plugin_callbacks[event]; (callback = *cbp); cbp = &callback->next) 497 if (strcmp (callback->plugin_name, plugin_name) == 0) 498 { 499 *cbp = callback->next; 500 return PLUGEVT_SUCCESS; 501 } 502 return PLUGEVT_NO_CALLBACK; 503} 504 505/* Invoke all plugin callbacks registered with the specified event, 506 called from invoke_plugin_callbacks(). */ 507 508int 509invoke_plugin_callbacks_full (int event, void *gcc_data) 510{ 511 int retval = PLUGEVT_SUCCESS; 512 513 timevar_push (TV_PLUGIN_RUN); 514 515 switch (event) 516 { 517 case PLUGIN_EVENT_FIRST_DYNAMIC: 518 default: 519 gcc_assert (event >= PLUGIN_EVENT_FIRST_DYNAMIC); 520 gcc_assert (event < event_last); 521 /* Fall through. */ 522 case PLUGIN_FINISH_TYPE: 523 case PLUGIN_FINISH_DECL: 524 case PLUGIN_START_UNIT: 525 case PLUGIN_FINISH_UNIT: 526 case PLUGIN_PRE_GENERICIZE: 527 case PLUGIN_ATTRIBUTES: 528 case PLUGIN_PRAGMAS: 529 case PLUGIN_FINISH: 530 case PLUGIN_GGC_START: 531 case PLUGIN_GGC_MARKING: 532 case PLUGIN_GGC_END: 533 case PLUGIN_ALL_PASSES_START: 534 case PLUGIN_ALL_PASSES_END: 535 case PLUGIN_ALL_IPA_PASSES_START: 536 case PLUGIN_ALL_IPA_PASSES_END: 537 case PLUGIN_OVERRIDE_GATE: 538 case PLUGIN_PASS_EXECUTION: 539 case PLUGIN_EARLY_GIMPLE_PASSES_START: 540 case PLUGIN_EARLY_GIMPLE_PASSES_END: 541 case PLUGIN_NEW_PASS: 542 case PLUGIN_INCLUDE_FILE: 543 { 544 /* Iterate over every callback registered with this event and 545 call it. */ 546 struct callback_info *callback = plugin_callbacks[event]; 547 548 if (!callback) 549 retval = PLUGEVT_NO_CALLBACK; 550 for ( ; callback; callback = callback->next) 551 (*callback->func) (gcc_data, callback->user_data); 552 } 553 break; 554 555 case PLUGIN_PASS_MANAGER_SETUP: 556 case PLUGIN_REGISTER_GGC_ROOTS: 557 gcc_assert (false); 558 } 559 560 timevar_pop (TV_PLUGIN_RUN); 561 return retval; 562} 563 564#ifdef ENABLE_PLUGIN 565/* We need a union to cast dlsym return value to a function pointer 566 as ISO C forbids assignment between function pointer and 'void *'. 567 Use explicit union instead of __extension__(<union_cast>) for 568 portability. */ 569#define PTR_UNION_TYPE(TOTYPE) union { void *_q; TOTYPE _nq; } 570#define PTR_UNION_AS_VOID_PTR(NAME) (NAME._q) 571#define PTR_UNION_AS_CAST_PTR(NAME) (NAME._nq) 572 573/* Try to initialize PLUGIN. Return true if successful. */ 574 575static bool 576try_init_one_plugin (struct plugin_name_args *plugin) 577{ 578 void *dl_handle; 579 plugin_init_func plugin_init; 580 const char *err; 581 PTR_UNION_TYPE (plugin_init_func) plugin_init_union; 582 583 /* We use RTLD_NOW to accelerate binding and detect any mismatch 584 between the API expected by the plugin and the GCC API; we use 585 RTLD_GLOBAL which is useful to plugins which themselves call 586 dlopen. */ 587 dl_handle = dlopen (plugin->full_name, RTLD_NOW | RTLD_GLOBAL); 588 if (!dl_handle) 589 { 590 error ("cannot load plugin %s\n%s", plugin->full_name, dlerror ()); 591 return false; 592 } 593 594 /* Clear any existing error. */ 595 dlerror (); 596 597 /* Check the plugin license. */ 598 if (dlsym (dl_handle, str_license) == NULL) 599 fatal_error (input_location, 600 "plugin %s is not licensed under a GPL-compatible license\n" 601 "%s", plugin->full_name, dlerror ()); 602 603 PTR_UNION_AS_VOID_PTR (plugin_init_union) = 604 dlsym (dl_handle, str_plugin_init_func_name); 605 plugin_init = PTR_UNION_AS_CAST_PTR (plugin_init_union); 606 607 if ((err = dlerror ()) != NULL) 608 { 609 error ("cannot find %s in plugin %s\n%s", str_plugin_init_func_name, 610 plugin->full_name, err); 611 return false; 612 } 613 614 /* Call the plugin-provided initialization routine with the arguments. */ 615 if ((*plugin_init) (plugin, &gcc_version)) 616 { 617 error ("fail to initialize plugin %s", plugin->full_name); 618 return false; 619 } 620 621 return true; 622} 623 624 625/* Routine to dlopen and initialize one plugin. This function is passed to 626 (and called by) the hash table traverse routine. Return 1 for the 627 htab_traverse to continue scan, 0 to stop. 628 629 SLOT - slot of the hash table element 630 INFO - auxiliary pointer handed to hash table traverse routine 631 (unused in this function) */ 632 633static int 634init_one_plugin (void **slot, void * ARG_UNUSED (info)) 635{ 636 struct plugin_name_args *plugin = (struct plugin_name_args *) *slot; 637 bool ok = try_init_one_plugin (plugin); 638 if (!ok) 639 { 640 htab_remove_elt (plugin_name_args_tab, plugin->base_name); 641 XDELETE (plugin); 642 } 643 return 1; 644} 645 646#endif /* ENABLE_PLUGIN */ 647 648/* Main plugin initialization function. Called from compile_file() in 649 toplev.c. */ 650 651void 652initialize_plugins (void) 653{ 654 /* If no plugin was specified in the command-line, simply return. */ 655 if (!plugin_name_args_tab) 656 return; 657 658 timevar_push (TV_PLUGIN_INIT); 659 660#ifdef ENABLE_PLUGIN 661 /* Traverse and initialize each plugin specified in the command-line. */ 662 htab_traverse_noresize (plugin_name_args_tab, init_one_plugin, NULL); 663#endif 664 665 timevar_pop (TV_PLUGIN_INIT); 666} 667 668/* Release memory used by one plugin. */ 669 670static int 671finalize_one_plugin (void **slot, void * ARG_UNUSED (info)) 672{ 673 struct plugin_name_args *plugin = (struct plugin_name_args *) *slot; 674 XDELETE (plugin); 675 return 1; 676} 677 678/* Free memory allocated by the plugin system. */ 679 680void 681finalize_plugins (void) 682{ 683 if (!plugin_name_args_tab) 684 return; 685 686 /* We can now delete the plugin_name_args object as it will no longer 687 be used. Note that base_name and argv fields (both of which were also 688 dynamically allocated) are not freed as they could still be used by 689 the plugin code. */ 690 691 htab_traverse_noresize (plugin_name_args_tab, finalize_one_plugin, NULL); 692 693 /* PLUGIN_NAME_ARGS_TAB is no longer needed, just delete it. */ 694 htab_delete (plugin_name_args_tab); 695 plugin_name_args_tab = NULL; 696} 697 698/* Used to pass options to htab_traverse callbacks. */ 699 700struct print_options 701{ 702 FILE *file; 703 const char *indent; 704}; 705 706/* Print the version of one plugin. */ 707 708static int 709print_version_one_plugin (void **slot, void *data) 710{ 711 struct print_options *opt = (struct print_options *) data; 712 struct plugin_name_args *plugin = (struct plugin_name_args *) *slot; 713 const char *version = plugin->version ? plugin->version : "Unknown version."; 714 715 fprintf (opt->file, " %s%s: %s\n", opt->indent, plugin->base_name, version); 716 return 1; 717} 718 719/* Print the version of each plugin. */ 720 721void 722print_plugins_versions (FILE *file, const char *indent) 723{ 724 struct print_options opt; 725 opt.file = file; 726 opt.indent = indent; 727 if (!plugin_name_args_tab || htab_elements (plugin_name_args_tab) == 0) 728 return; 729 730 fprintf (file, "%sVersions of loaded plugins:\n", indent); 731 htab_traverse_noresize (plugin_name_args_tab, print_version_one_plugin, &opt); 732} 733 734/* Print help for one plugin. SLOT is the hash table slot. DATA is the 735 argument to htab_traverse_noresize. */ 736 737static int 738print_help_one_plugin (void **slot, void *data) 739{ 740 struct print_options *opt = (struct print_options *) data; 741 struct plugin_name_args *plugin = (struct plugin_name_args *) *slot; 742 const char *help = plugin->help ? plugin->help : "No help available ."; 743 744 char *dup = xstrdup (help); 745 char *p, *nl; 746 fprintf (opt->file, " %s%s:\n", opt->indent, plugin->base_name); 747 748 for (p = nl = dup; nl; p = nl) 749 { 750 nl = strchr (nl, '\n'); 751 if (nl) 752 { 753 *nl = '\0'; 754 nl++; 755 } 756 fprintf (opt->file, " %s %s\n", opt->indent, p); 757 } 758 759 free (dup); 760 return 1; 761} 762 763/* Print help for each plugin. The output goes to FILE and every line starts 764 with INDENT. */ 765 766void 767print_plugins_help (FILE *file, const char *indent) 768{ 769 struct print_options opt; 770 opt.file = file; 771 opt.indent = indent; 772 if (!plugin_name_args_tab || htab_elements (plugin_name_args_tab) == 0) 773 return; 774 775 fprintf (file, "%sHelp for the loaded plugins:\n", indent); 776 htab_traverse_noresize (plugin_name_args_tab, print_help_one_plugin, &opt); 777} 778 779 780/* Return true if plugins have been loaded. */ 781 782bool 783plugins_active_p (void) 784{ 785 int event; 786 787 for (event = PLUGIN_PASS_MANAGER_SETUP; event < event_last; event++) 788 if (plugin_callbacks[event]) 789 return true; 790 791 return false; 792} 793 794 795/* Dump to FILE the names and associated events for all the active 796 plugins. */ 797 798DEBUG_FUNCTION void 799dump_active_plugins (FILE *file) 800{ 801 int event; 802 803 if (!plugins_active_p ()) 804 return; 805 806 fprintf (file, FMT_FOR_PLUGIN_EVENT " | %s\n", _("Event"), _("Plugins")); 807 for (event = PLUGIN_PASS_MANAGER_SETUP; event < event_last; event++) 808 if (plugin_callbacks[event]) 809 { 810 struct callback_info *ci; 811 812 fprintf (file, FMT_FOR_PLUGIN_EVENT " |", plugin_event_name[event]); 813 814 for (ci = plugin_callbacks[event]; ci; ci = ci->next) 815 fprintf (file, " %s", ci->plugin_name); 816 817 putc ('\n', file); 818 } 819} 820 821 822/* Dump active plugins to stderr. */ 823 824DEBUG_FUNCTION void 825debug_active_plugins (void) 826{ 827 dump_active_plugins (stderr); 828} 829 830/* Give a warning if plugins are present, before an ICE message asking 831 to submit a bug report. */ 832 833void 834warn_if_plugins (void) 835{ 836 if (plugins_active_p ()) 837 { 838 fnotice (stderr, "*** WARNING *** there are active plugins, do not report" 839 " this as a bug unless you can reproduce it without enabling" 840 " any plugins.\n"); 841 dump_active_plugins (stderr); 842 } 843 844} 845 846/* Likewise, as a callback from the diagnostics code. */ 847 848void 849plugins_internal_error_function (diagnostic_context *context ATTRIBUTE_UNUSED, 850 const char *msgid ATTRIBUTE_UNUSED, 851 va_list *ap ATTRIBUTE_UNUSED) 852{ 853 warn_if_plugins (); 854} 855 856/* The default version check. Compares every field in VERSION. */ 857 858bool 859plugin_default_version_check (struct plugin_gcc_version *gcc_version, 860 struct plugin_gcc_version *plugin_version) 861{ 862 if (!gcc_version || !plugin_version) 863 return false; 864 865 if (strcmp (gcc_version->basever, plugin_version->basever)) 866 return false; 867 if (strcmp (gcc_version->datestamp, plugin_version->datestamp)) 868 return false; 869 if (strcmp (gcc_version->devphase, plugin_version->devphase)) 870 return false; 871 if (strcmp (gcc_version->revision, plugin_version->revision)) 872 return false; 873 if (strcmp (gcc_version->configuration_arguments, 874 plugin_version->configuration_arguments)) 875 return false; 876 return true; 877} 878 879 880/* Return the current value of event_last, so that plugins which provide 881 additional functionality for events for the benefit of high-level plugins 882 know how many valid entries plugin_event_name holds. */ 883 884int 885get_event_last (void) 886{ 887 return event_last; 888} 889 890 891/* Retrieve the default plugin directory. The gcc driver should have passed 892 it as -iplugindir <dir> to the cc1 program, and it is queriable through the 893 -print-file-name=plugin option to gcc. */ 894const char* 895default_plugin_dir_name (void) 896{ 897 if (!plugindir_string) 898 fatal_error (input_location, 899 "-iplugindir <dir> option not passed from the gcc driver"); 900 return plugindir_string; 901} 902