gcc/plugin.c

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