gcc/plugin.c

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