gcc/plugin.c

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