OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gcc-4.5.1/] [gcc/] [plugin.c] - Diff between revs 816 and 826

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 816 Rev 826
/* Support for GCC plugin mechanism.
/* Support for GCC plugin mechanism.
   Copyright (C) 2009 Free Software Foundation, Inc.
   Copyright (C) 2009 Free Software Foundation, Inc.
 
 
This file is part of GCC.
This file is part of GCC.
 
 
GCC is free software; you can redistribute it and/or modify
GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
the Free Software Foundation; either version 3, or (at your option)
any later version.
any later version.
 
 
GCC is distributed in the hope that it will be useful,
GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
GNU General Public License for more details.
 
 
You should have received a copy of the GNU General Public License
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.  */
<http://www.gnu.org/licenses/>.  */
 
 
/* This file contains the support for GCC plugin mechanism based on the
/* This file contains the support for GCC plugin mechanism based on the
   APIs described in doc/plugin.texi.  */
   APIs described in doc/plugin.texi.  */
 
 
#include "config.h"
#include "config.h"
#include "system.h"
#include "system.h"
 
 
/* If plugin support is not enabled, do not try to execute any code
/* If plugin support is not enabled, do not try to execute any code
   that may reference libdl.  The generic code is still compiled in to
   that may reference libdl.  The generic code is still compiled in to
   avoid including too many conditional compilation paths in the rest
   avoid including too many conditional compilation paths in the rest
   of the compiler.  */
   of the compiler.  */
#ifdef ENABLE_PLUGIN
#ifdef ENABLE_PLUGIN
#include <dlfcn.h>
#include <dlfcn.h>
#endif
#endif
 
 
#include "coretypes.h"
#include "coretypes.h"
#include "toplev.h"
#include "toplev.h"
#include "tree.h"
#include "tree.h"
#include "tree-pass.h"
#include "tree-pass.h"
#include "intl.h"
#include "intl.h"
#include "plugin.h"
#include "plugin.h"
#include "timevar.h"
#include "timevar.h"
#include "ggc.h"
#include "ggc.h"
 
 
#ifdef ENABLE_PLUGIN
#ifdef ENABLE_PLUGIN
#include "plugin-version.h"
#include "plugin-version.h"
#endif
#endif
 
 
#define GCC_PLUGIN_STRINGIFY0(X) #X
#define GCC_PLUGIN_STRINGIFY0(X) #X
#define GCC_PLUGIN_STRINGIFY1(X) GCC_PLUGIN_STRINGIFY0 (X)
#define GCC_PLUGIN_STRINGIFY1(X) GCC_PLUGIN_STRINGIFY0 (X)
 
 
/* Event names as strings.  Keep in sync with enum plugin_event.  */
/* Event names as strings.  Keep in sync with enum plugin_event.  */
static const char *plugin_event_name_init[] =
static const char *plugin_event_name_init[] =
{
{
# define DEFEVENT(NAME) GCC_PLUGIN_STRINGIFY1 (NAME),
# define DEFEVENT(NAME) GCC_PLUGIN_STRINGIFY1 (NAME),
# include "plugin.def"
# include "plugin.def"
# undef DEFEVENT
# undef DEFEVENT
};
};
 
 
/* A printf format large enough for the largest event above.  */
/* A printf format large enough for the largest event above.  */
#define FMT_FOR_PLUGIN_EVENT "%-32s"
#define FMT_FOR_PLUGIN_EVENT "%-32s"
 
 
const char **plugin_event_name = plugin_event_name_init;
const char **plugin_event_name = plugin_event_name_init;
 
 
/* A hash table to map event names to the position of the names in the
/* A hash table to map event names to the position of the names in the
   plugin_event_name table.  */
   plugin_event_name table.  */
static htab_t event_tab;
static htab_t event_tab;
 
 
/* Keep track of the limit of allocated events and space ready for
/* Keep track of the limit of allocated events and space ready for
   allocating events.  */
   allocating events.  */
static int event_last = PLUGIN_EVENT_FIRST_DYNAMIC;
static int event_last = PLUGIN_EVENT_FIRST_DYNAMIC;
static int event_horizon = PLUGIN_EVENT_FIRST_DYNAMIC;
static int event_horizon = PLUGIN_EVENT_FIRST_DYNAMIC;
 
 
/* Hash table for the plugin_name_args objects created during command-line
/* Hash table for the plugin_name_args objects created during command-line
   parsing.  */
   parsing.  */
static htab_t plugin_name_args_tab = NULL;
static htab_t plugin_name_args_tab = NULL;
 
 
/* List node for keeping track of plugin-registered callback.  */
/* List node for keeping track of plugin-registered callback.  */
struct callback_info
struct callback_info
{
{
  const char *plugin_name;   /* Name of plugin that registers the callback.  */
  const char *plugin_name;   /* Name of plugin that registers the callback.  */
  plugin_callback_func func; /* Callback to be called.  */
  plugin_callback_func func; /* Callback to be called.  */
  void *user_data;           /* plugin-specified data.  */
  void *user_data;           /* plugin-specified data.  */
  struct callback_info *next;
  struct callback_info *next;
};
};
 
 
/* An array of lists of 'callback_info' objects indexed by the event id.  */
/* An array of lists of 'callback_info' objects indexed by the event id.  */
static struct callback_info *plugin_callbacks_init[PLUGIN_EVENT_FIRST_DYNAMIC];
static struct callback_info *plugin_callbacks_init[PLUGIN_EVENT_FIRST_DYNAMIC];
static struct callback_info **plugin_callbacks = plugin_callbacks_init;
static struct callback_info **plugin_callbacks = plugin_callbacks_init;
 
 
 
 
#ifdef ENABLE_PLUGIN
#ifdef ENABLE_PLUGIN
/* Each plugin should define an initialization function with exactly
/* Each plugin should define an initialization function with exactly
   this name.  */
   this name.  */
static const char *str_plugin_init_func_name = "plugin_init";
static const char *str_plugin_init_func_name = "plugin_init";
 
 
/* Each plugin should define this symbol to assert that it is
/* Each plugin should define this symbol to assert that it is
   distributed under a GPL-compatible license.  */
   distributed under a GPL-compatible license.  */
static const char *str_license = "plugin_is_GPL_compatible";
static const char *str_license = "plugin_is_GPL_compatible";
#endif
#endif
 
 
/* Helper function for the hash table that compares the base_name of the
/* Helper function for the hash table that compares the base_name of the
   existing entry (S1) with the given string (S2).  */
   existing entry (S1) with the given string (S2).  */
 
 
static int
static int
htab_str_eq (const void *s1, const void *s2)
htab_str_eq (const void *s1, const void *s2)
{
{
  const struct plugin_name_args *plugin = (const struct plugin_name_args *) s1;
  const struct plugin_name_args *plugin = (const struct plugin_name_args *) s1;
  return !strcmp (plugin->base_name, (const char *) s2);
  return !strcmp (plugin->base_name, (const char *) s2);
}
}
 
 
 
 
/* Given a plugin's full-path name FULL_NAME, e.g. /pass/to/NAME.so,
/* Given a plugin's full-path name FULL_NAME, e.g. /pass/to/NAME.so,
   return NAME.  */
   return NAME.  */
 
 
static char *
static char *
get_plugin_base_name (const char *full_name)
get_plugin_base_name (const char *full_name)
{
{
  /* First get the base name part of the full-path name, i.e. NAME.so.  */
  /* First get the base name part of the full-path name, i.e. NAME.so.  */
  char *base_name = xstrdup (lbasename (full_name));
  char *base_name = xstrdup (lbasename (full_name));
 
 
  /* Then get rid of '.so' part of the name.  */
  /* Then get rid of '.so' part of the name.  */
  strip_off_ending (base_name, strlen (base_name));
  strip_off_ending (base_name, strlen (base_name));
 
 
  return base_name;
  return base_name;
}
}
 
 
 
 
/* Create a plugin_name_args object for the give plugin and insert it to
/* Create a plugin_name_args object for the give plugin and insert it to
   the hash table. This function is called when -fplugin=/path/to/NAME.so
   the hash table. This function is called when -fplugin=/path/to/NAME.so
   option is processed.  */
   option is processed.  */
 
 
void
void
add_new_plugin (const char* plugin_name)
add_new_plugin (const char* plugin_name)
{
{
  struct plugin_name_args *plugin;
  struct plugin_name_args *plugin;
  void **slot;
  void **slot;
  char *base_name = get_plugin_base_name (plugin_name);
  char *base_name = get_plugin_base_name (plugin_name);
 
 
  /* If this is the first -fplugin= option we encounter, create
  /* If this is the first -fplugin= option we encounter, create
     'plugin_name_args_tab' hash table.  */
     'plugin_name_args_tab' hash table.  */
  if (!plugin_name_args_tab)
  if (!plugin_name_args_tab)
    plugin_name_args_tab = htab_create (10, htab_hash_string, htab_str_eq,
    plugin_name_args_tab = htab_create (10, htab_hash_string, htab_str_eq,
                                        NULL);
                                        NULL);
 
 
  slot = htab_find_slot (plugin_name_args_tab, base_name, INSERT);
  slot = htab_find_slot (plugin_name_args_tab, base_name, INSERT);
 
 
  /* If the same plugin (name) has been specified earlier, either emit an
  /* If the same plugin (name) has been specified earlier, either emit an
     error or a warning message depending on if they have identical full
     error or a warning message depending on if they have identical full
     (path) names.  */
     (path) names.  */
  if (*slot)
  if (*slot)
    {
    {
      plugin = (struct plugin_name_args *) *slot;
      plugin = (struct plugin_name_args *) *slot;
      if (strcmp (plugin->full_name, plugin_name))
      if (strcmp (plugin->full_name, plugin_name))
        error ("Plugin %s was specified with different paths:\n%s\n%s",
        error ("Plugin %s was specified with different paths:\n%s\n%s",
               plugin->base_name, plugin->full_name, plugin_name);
               plugin->base_name, plugin->full_name, plugin_name);
      return;
      return;
    }
    }
 
 
  plugin = XCNEW (struct plugin_name_args);
  plugin = XCNEW (struct plugin_name_args);
  plugin->base_name = base_name;
  plugin->base_name = base_name;
  plugin->full_name = plugin_name;
  plugin->full_name = plugin_name;
 
 
  *slot = plugin;
  *slot = plugin;
}
}
 
 
 
 
/* Parse the -fplugin-arg-<name>-<key>[=<value>] option and create a
/* Parse the -fplugin-arg-<name>-<key>[=<value>] option and create a
   'plugin_argument' object for the parsed key-value pair. ARG is
   'plugin_argument' object for the parsed key-value pair. ARG is
   the <name>-<key>[=<value>] part of the option.  */
   the <name>-<key>[=<value>] part of the option.  */
 
 
void
void
parse_plugin_arg_opt (const char *arg)
parse_plugin_arg_opt (const char *arg)
{
{
  size_t len = 0, name_len = 0, key_len = 0, value_len = 0;
  size_t len = 0, name_len = 0, key_len = 0, value_len = 0;
  const char *ptr, *name_start = arg, *key_start = NULL, *value_start = NULL;
  const char *ptr, *name_start = arg, *key_start = NULL, *value_start = NULL;
  char *name, *key, *value;
  char *name, *key, *value;
  void **slot;
  void **slot;
  bool name_parsed = false, key_parsed = false;
  bool name_parsed = false, key_parsed = false;
 
 
  /* Iterate over the ARG string and identify the starting character position
  /* Iterate over the ARG string and identify the starting character position
     of 'name', 'key', and 'value' and their lengths.  */
     of 'name', 'key', and 'value' and their lengths.  */
  for (ptr = arg; *ptr; ++ptr)
  for (ptr = arg; *ptr; ++ptr)
    {
    {
      /* Only the first '-' encountered is considered a separator between
      /* Only the first '-' encountered is considered a separator between
         'name' and 'key'. All the subsequent '-'s are considered part of
         'name' and 'key'. All the subsequent '-'s are considered part of
         'key'. For example, given -fplugin-arg-foo-bar-primary-key=value,
         'key'. For example, given -fplugin-arg-foo-bar-primary-key=value,
         the plugin name is 'foo' and the key is 'bar-primary-key'.  */
         the plugin name is 'foo' and the key is 'bar-primary-key'.  */
      if (*ptr == '-' && !name_parsed)
      if (*ptr == '-' && !name_parsed)
        {
        {
          name_len = len;
          name_len = len;
          len = 0;
          len = 0;
          key_start = ptr + 1;
          key_start = ptr + 1;
          name_parsed = true;
          name_parsed = true;
          continue;
          continue;
        }
        }
      else if (*ptr == '=')
      else if (*ptr == '=')
        {
        {
          if (key_parsed)
          if (key_parsed)
            {
            {
              error ("Malformed option -fplugin-arg-%s (multiple '=' signs)",
              error ("Malformed option -fplugin-arg-%s (multiple '=' signs)",
                     arg);
                     arg);
              return;
              return;
            }
            }
          key_len = len;
          key_len = len;
          len = 0;
          len = 0;
          value_start = ptr + 1;
          value_start = ptr + 1;
          key_parsed = true;
          key_parsed = true;
          continue;
          continue;
        }
        }
      else
      else
        ++len;
        ++len;
    }
    }
 
 
  if (!key_start)
  if (!key_start)
    {
    {
      error ("Malformed option -fplugin-arg-%s (missing -<key>[=<value>])",
      error ("Malformed option -fplugin-arg-%s (missing -<key>[=<value>])",
             arg);
             arg);
      return;
      return;
    }
    }
 
 
  /* If the option doesn't contain the 'value' part, LEN is the KEY_LEN.
  /* If the option doesn't contain the 'value' part, LEN is the KEY_LEN.
     Otherwise, it is the VALUE_LEN.  */
     Otherwise, it is the VALUE_LEN.  */
  if (!value_start)
  if (!value_start)
    key_len = len;
    key_len = len;
  else
  else
    value_len = len;
    value_len = len;
 
 
  name = XNEWVEC (char, name_len + 1);
  name = XNEWVEC (char, name_len + 1);
  strncpy (name, name_start, name_len);
  strncpy (name, name_start, name_len);
  name[name_len] = '\0';
  name[name_len] = '\0';
 
 
  /* Check if the named plugin has already been specified earlier in the
  /* Check if the named plugin has already been specified earlier in the
     command-line.  */
     command-line.  */
  if (plugin_name_args_tab
  if (plugin_name_args_tab
      && ((slot = htab_find_slot (plugin_name_args_tab, name, NO_INSERT))
      && ((slot = htab_find_slot (plugin_name_args_tab, name, NO_INSERT))
          != NULL))
          != NULL))
    {
    {
      struct plugin_name_args *plugin = (struct plugin_name_args *) *slot;
      struct plugin_name_args *plugin = (struct plugin_name_args *) *slot;
 
 
      key = XNEWVEC (char, key_len + 1);
      key = XNEWVEC (char, key_len + 1);
      strncpy (key, key_start, key_len);
      strncpy (key, key_start, key_len);
      key[key_len] = '\0';
      key[key_len] = '\0';
      if (value_start)
      if (value_start)
        {
        {
          value = XNEWVEC (char, value_len + 1);
          value = XNEWVEC (char, value_len + 1);
          strncpy (value, value_start, value_len);
          strncpy (value, value_start, value_len);
          value[value_len] = '\0';
          value[value_len] = '\0';
        }
        }
      else
      else
        value = NULL;
        value = NULL;
 
 
      /* Create a plugin_argument object for the parsed key-value pair.
      /* Create a plugin_argument object for the parsed key-value pair.
         If there are already arguments for this plugin, we will need to
         If there are already arguments for this plugin, we will need to
         adjust the argument array size by creating a new array and deleting
         adjust the argument array size by creating a new array and deleting
         the old one. If the performance ever becomes an issue, we can
         the old one. If the performance ever becomes an issue, we can
         change the code by pre-allocating a larger array first.  */
         change the code by pre-allocating a larger array first.  */
      if (plugin->argc > 0)
      if (plugin->argc > 0)
        {
        {
          struct plugin_argument *args = XNEWVEC (struct plugin_argument,
          struct plugin_argument *args = XNEWVEC (struct plugin_argument,
                                                  plugin->argc + 1);
                                                  plugin->argc + 1);
          memcpy (args, plugin->argv,
          memcpy (args, plugin->argv,
                  sizeof (struct plugin_argument) * plugin->argc);
                  sizeof (struct plugin_argument) * plugin->argc);
          XDELETEVEC (plugin->argv);
          XDELETEVEC (plugin->argv);
          plugin->argv = args;
          plugin->argv = args;
          ++plugin->argc;
          ++plugin->argc;
        }
        }
      else
      else
        {
        {
          gcc_assert (plugin->argv == NULL);
          gcc_assert (plugin->argv == NULL);
          plugin->argv = XNEWVEC (struct plugin_argument, 1);
          plugin->argv = XNEWVEC (struct plugin_argument, 1);
          plugin->argc = 1;
          plugin->argc = 1;
        }
        }
 
 
      plugin->argv[plugin->argc - 1].key = key;
      plugin->argv[plugin->argc - 1].key = key;
      plugin->argv[plugin->argc - 1].value = value;
      plugin->argv[plugin->argc - 1].value = value;
    }
    }
  else
  else
    error ("Plugin %s should be specified before -fplugin-arg-%s "
    error ("Plugin %s should be specified before -fplugin-arg-%s "
           "in the command line", name, arg);
           "in the command line", name, arg);
 
 
  /* We don't need the plugin's name anymore. Just release it.  */
  /* We don't need the plugin's name anymore. Just release it.  */
  XDELETEVEC (name);
  XDELETEVEC (name);
}
}
 
 
/* Register additional plugin information. NAME is the name passed to
/* Register additional plugin information. NAME is the name passed to
   plugin_init. INFO is the information that should be registered. */
   plugin_init. INFO is the information that should be registered. */
 
 
static void
static void
register_plugin_info (const char* name, struct plugin_info *info)
register_plugin_info (const char* name, struct plugin_info *info)
{
{
  void **slot = htab_find_slot (plugin_name_args_tab, name, NO_INSERT);
  void **slot = htab_find_slot (plugin_name_args_tab, name, NO_INSERT);
  struct plugin_name_args *plugin = (struct plugin_name_args *) *slot;
  struct plugin_name_args *plugin = (struct plugin_name_args *) *slot;
  plugin->version = info->version;
  plugin->version = info->version;
  plugin->help = info->help;
  plugin->help = info->help;
}
}
 
 
/* Helper function for the event hash table that compares the name of an
/* Helper function for the event hash table that compares the name of an
   existing entry (E1) with the given string (S2).  */
   existing entry (E1) with the given string (S2).  */
 
 
static int
static int
htab_event_eq (const void *e1, const void *s2)
htab_event_eq (const void *e1, const void *s2)
{
{
  const char *s1= *(const char * const *) e1;
  const char *s1= *(const char * const *) e1;
  return !strcmp (s1, (const char *) s2);
  return !strcmp (s1, (const char *) s2);
}
}
 
 
/* Look up the event id for NAME.  If the name is not found, return -1
/* Look up the event id for NAME.  If the name is not found, return -1
   if INSERT is NO_INSERT.  */
   if INSERT is NO_INSERT.  */
 
 
int
int
get_named_event_id (const char *name, enum insert_option insert)
get_named_event_id (const char *name, enum insert_option insert)
{
{
  void **slot;
  void **slot;
 
 
  if (!event_tab)
  if (!event_tab)
    {
    {
      int i;
      int i;
 
 
      event_tab = htab_create (150, htab_hash_string, htab_event_eq, NULL);
      event_tab = htab_create (150, htab_hash_string, htab_event_eq, NULL);
      for (i = 0; i < event_last; i++)
      for (i = 0; i < event_last; i++)
        {
        {
          slot = htab_find_slot (event_tab, plugin_event_name[i], INSERT);
          slot = htab_find_slot (event_tab, plugin_event_name[i], INSERT);
          gcc_assert (*slot == HTAB_EMPTY_ENTRY);
          gcc_assert (*slot == HTAB_EMPTY_ENTRY);
          *slot = &plugin_event_name[i];
          *slot = &plugin_event_name[i];
        }
        }
    }
    }
  slot = htab_find_slot (event_tab, name, insert);
  slot = htab_find_slot (event_tab, name, insert);
  if (slot == NULL)
  if (slot == NULL)
    return -1;
    return -1;
  if (*slot != HTAB_EMPTY_ENTRY)
  if (*slot != HTAB_EMPTY_ENTRY)
    return (const char **) *slot - &plugin_event_name[0];
    return (const char **) *slot - &plugin_event_name[0];
 
 
  if (event_last >= event_horizon)
  if (event_last >= event_horizon)
    {
    {
      event_horizon = event_last * 2;
      event_horizon = event_last * 2;
      if (plugin_event_name == plugin_event_name_init)
      if (plugin_event_name == plugin_event_name_init)
        {
        {
          plugin_event_name = XNEWVEC (const char *, event_horizon);
          plugin_event_name = XNEWVEC (const char *, event_horizon);
          memcpy (plugin_event_name, plugin_event_name_init,
          memcpy (plugin_event_name, plugin_event_name_init,
                  sizeof plugin_event_name_init);
                  sizeof plugin_event_name_init);
          plugin_callbacks = XNEWVEC (struct callback_info *, event_horizon);
          plugin_callbacks = XNEWVEC (struct callback_info *, event_horizon);
          memcpy (plugin_callbacks, plugin_callbacks_init,
          memcpy (plugin_callbacks, plugin_callbacks_init,
                  sizeof plugin_callbacks_init);
                  sizeof plugin_callbacks_init);
        }
        }
      else
      else
        {
        {
          plugin_event_name
          plugin_event_name
            = XRESIZEVEC (const char *, plugin_event_name, event_horizon);
            = XRESIZEVEC (const char *, plugin_event_name, event_horizon);
          plugin_callbacks = XRESIZEVEC (struct callback_info *,
          plugin_callbacks = XRESIZEVEC (struct callback_info *,
                                         plugin_callbacks, event_horizon);
                                         plugin_callbacks, event_horizon);
        }
        }
      /* All the pointers in the hash table will need to be updated.  */
      /* All the pointers in the hash table will need to be updated.  */
      htab_delete (event_tab);
      htab_delete (event_tab);
      event_tab = NULL;
      event_tab = NULL;
    }
    }
  else
  else
    *slot = &plugin_event_name[event_last];
    *slot = &plugin_event_name[event_last];
  plugin_event_name[event_last] = name;
  plugin_event_name[event_last] = name;
  return event_last++;
  return event_last++;
}
}
 
 
/* Called from the plugin's initialization code. Register a single callback.
/* Called from the plugin's initialization code. Register a single callback.
   This function can be called multiple times.
   This function can be called multiple times.
 
 
   PLUGIN_NAME - display name for this plugin
   PLUGIN_NAME - display name for this plugin
   EVENT       - which event the callback is for
   EVENT       - which event the callback is for
   CALLBACK    - the callback to be called at the event
   CALLBACK    - the callback to be called at the event
   USER_DATA   - plugin-provided data   */
   USER_DATA   - plugin-provided data   */
 
 
void
void
register_callback (const char *plugin_name,
register_callback (const char *plugin_name,
                   int event,
                   int event,
                   plugin_callback_func callback,
                   plugin_callback_func callback,
                   void *user_data)
                   void *user_data)
{
{
  switch (event)
  switch (event)
    {
    {
      case PLUGIN_PASS_MANAGER_SETUP:
      case PLUGIN_PASS_MANAGER_SETUP:
        gcc_assert (!callback);
        gcc_assert (!callback);
        register_pass ((struct register_pass_info *) user_data);
        register_pass ((struct register_pass_info *) user_data);
        break;
        break;
      case PLUGIN_INFO:
      case PLUGIN_INFO:
        gcc_assert (!callback);
        gcc_assert (!callback);
        register_plugin_info (plugin_name, (struct plugin_info *) user_data);
        register_plugin_info (plugin_name, (struct plugin_info *) user_data);
        break;
        break;
      case PLUGIN_REGISTER_GGC_ROOTS:
      case PLUGIN_REGISTER_GGC_ROOTS:
        gcc_assert (!callback);
        gcc_assert (!callback);
        ggc_register_root_tab ((const struct ggc_root_tab*) user_data);
        ggc_register_root_tab ((const struct ggc_root_tab*) user_data);
        break;
        break;
      case PLUGIN_REGISTER_GGC_CACHES:
      case PLUGIN_REGISTER_GGC_CACHES:
        gcc_assert (!callback);
        gcc_assert (!callback);
        ggc_register_cache_tab ((const struct ggc_cache_tab*) user_data);
        ggc_register_cache_tab ((const struct ggc_cache_tab*) user_data);
        break;
        break;
      case PLUGIN_EVENT_FIRST_DYNAMIC:
      case PLUGIN_EVENT_FIRST_DYNAMIC:
      default:
      default:
        if (event < PLUGIN_EVENT_FIRST_DYNAMIC || event >= event_last)
        if (event < PLUGIN_EVENT_FIRST_DYNAMIC || event >= event_last)
          {
          {
            error ("Unknown callback event registered by plugin %s",
            error ("Unknown callback event registered by plugin %s",
                   plugin_name);
                   plugin_name);
            return;
            return;
          }
          }
      /* Fall through.  */
      /* Fall through.  */
      case PLUGIN_FINISH_TYPE:
      case PLUGIN_FINISH_TYPE:
      case PLUGIN_START_UNIT:
      case PLUGIN_START_UNIT:
      case PLUGIN_FINISH_UNIT:
      case PLUGIN_FINISH_UNIT:
      case PLUGIN_PRE_GENERICIZE:
      case PLUGIN_PRE_GENERICIZE:
      case PLUGIN_GGC_START:
      case PLUGIN_GGC_START:
      case PLUGIN_GGC_MARKING:
      case PLUGIN_GGC_MARKING:
      case PLUGIN_GGC_END:
      case PLUGIN_GGC_END:
      case PLUGIN_ATTRIBUTES:
      case PLUGIN_ATTRIBUTES:
      case PLUGIN_PRAGMAS:
      case PLUGIN_PRAGMAS:
      case PLUGIN_FINISH:
      case PLUGIN_FINISH:
      case PLUGIN_ALL_PASSES_START:
      case PLUGIN_ALL_PASSES_START:
      case PLUGIN_ALL_PASSES_END:
      case PLUGIN_ALL_PASSES_END:
      case PLUGIN_ALL_IPA_PASSES_START:
      case PLUGIN_ALL_IPA_PASSES_START:
      case PLUGIN_ALL_IPA_PASSES_END:
      case PLUGIN_ALL_IPA_PASSES_END:
      case PLUGIN_OVERRIDE_GATE:
      case PLUGIN_OVERRIDE_GATE:
      case PLUGIN_PASS_EXECUTION:
      case PLUGIN_PASS_EXECUTION:
      case PLUGIN_EARLY_GIMPLE_PASSES_START:
      case PLUGIN_EARLY_GIMPLE_PASSES_START:
      case PLUGIN_EARLY_GIMPLE_PASSES_END:
      case PLUGIN_EARLY_GIMPLE_PASSES_END:
      case PLUGIN_NEW_PASS:
      case PLUGIN_NEW_PASS:
        {
        {
          struct callback_info *new_callback;
          struct callback_info *new_callback;
          if (!callback)
          if (!callback)
            {
            {
              error ("Plugin %s registered a null callback function "
              error ("Plugin %s registered a null callback function "
                     "for event %s", plugin_name, plugin_event_name[event]);
                     "for event %s", plugin_name, plugin_event_name[event]);
              return;
              return;
            }
            }
          new_callback = XNEW (struct callback_info);
          new_callback = XNEW (struct callback_info);
          new_callback->plugin_name = plugin_name;
          new_callback->plugin_name = plugin_name;
          new_callback->func = callback;
          new_callback->func = callback;
          new_callback->user_data = user_data;
          new_callback->user_data = user_data;
          new_callback->next = plugin_callbacks[event];
          new_callback->next = plugin_callbacks[event];
          plugin_callbacks[event] = new_callback;
          plugin_callbacks[event] = new_callback;
        }
        }
        break;
        break;
    }
    }
}
}
 
 
/* Remove a callback for EVENT which has been registered with for a plugin
/* Remove a callback for EVENT which has been registered with for a plugin
   PLUGIN_NAME.  Return PLUGEVT_SUCCESS if a matching callback was
   PLUGIN_NAME.  Return PLUGEVT_SUCCESS if a matching callback was
   found & removed, PLUGEVT_NO_CALLBACK if the event does not have a matching
   found & removed, PLUGEVT_NO_CALLBACK if the event does not have a matching
   callback, and PLUGEVT_NO_SUCH_EVENT if EVENT is invalid.  */
   callback, and PLUGEVT_NO_SUCH_EVENT if EVENT is invalid.  */
int
int
unregister_callback (const char *plugin_name, int event)
unregister_callback (const char *plugin_name, int event)
{
{
  struct callback_info *callback, **cbp;
  struct callback_info *callback, **cbp;
 
 
  if (event >= event_last)
  if (event >= event_last)
    return PLUGEVT_NO_SUCH_EVENT;
    return PLUGEVT_NO_SUCH_EVENT;
 
 
  for (cbp = &plugin_callbacks[event]; (callback = *cbp); cbp = &callback->next)
  for (cbp = &plugin_callbacks[event]; (callback = *cbp); cbp = &callback->next)
    if (strcmp (callback->plugin_name, plugin_name) == 0)
    if (strcmp (callback->plugin_name, plugin_name) == 0)
      {
      {
        *cbp = callback->next;
        *cbp = callback->next;
        return PLUGEVT_SUCCESS;
        return PLUGEVT_SUCCESS;
      }
      }
  return PLUGEVT_NO_CALLBACK;
  return PLUGEVT_NO_CALLBACK;
}
}
 
 
/* Called from inside GCC.  Invoke all plug-in callbacks registered with
/* Called from inside GCC.  Invoke all plug-in callbacks registered with
   the specified event.
   the specified event.
   Return PLUGEVT_SUCCESS if at least one callback was called,
   Return PLUGEVT_SUCCESS if at least one callback was called,
   PLUGEVT_NO_CALLBACK if there was no callback.
   PLUGEVT_NO_CALLBACK if there was no callback.
 
 
   EVENT    - the event identifier
   EVENT    - the event identifier
   GCC_DATA - event-specific data provided by the compiler  */
   GCC_DATA - event-specific data provided by the compiler  */
 
 
int
int
invoke_plugin_callbacks (int event, void *gcc_data)
invoke_plugin_callbacks (int event, void *gcc_data)
{
{
  int retval = PLUGEVT_SUCCESS;
  int retval = PLUGEVT_SUCCESS;
 
 
  timevar_push (TV_PLUGIN_RUN);
  timevar_push (TV_PLUGIN_RUN);
 
 
  switch (event)
  switch (event)
    {
    {
      case PLUGIN_EVENT_FIRST_DYNAMIC:
      case PLUGIN_EVENT_FIRST_DYNAMIC:
      default:
      default:
        gcc_assert (event >= PLUGIN_EVENT_FIRST_DYNAMIC);
        gcc_assert (event >= PLUGIN_EVENT_FIRST_DYNAMIC);
        gcc_assert (event < event_last);
        gcc_assert (event < event_last);
      /* Fall through.  */
      /* Fall through.  */
      case PLUGIN_FINISH_TYPE:
      case PLUGIN_FINISH_TYPE:
      case PLUGIN_START_UNIT:
      case PLUGIN_START_UNIT:
      case PLUGIN_FINISH_UNIT:
      case PLUGIN_FINISH_UNIT:
      case PLUGIN_PRE_GENERICIZE:
      case PLUGIN_PRE_GENERICIZE:
      case PLUGIN_ATTRIBUTES:
      case PLUGIN_ATTRIBUTES:
      case PLUGIN_PRAGMAS:
      case PLUGIN_PRAGMAS:
      case PLUGIN_FINISH:
      case PLUGIN_FINISH:
      case PLUGIN_GGC_START:
      case PLUGIN_GGC_START:
      case PLUGIN_GGC_MARKING:
      case PLUGIN_GGC_MARKING:
      case PLUGIN_GGC_END:
      case PLUGIN_GGC_END:
      case PLUGIN_ALL_PASSES_START:
      case PLUGIN_ALL_PASSES_START:
      case PLUGIN_ALL_PASSES_END:
      case PLUGIN_ALL_PASSES_END:
      case PLUGIN_ALL_IPA_PASSES_START:
      case PLUGIN_ALL_IPA_PASSES_START:
      case PLUGIN_ALL_IPA_PASSES_END:
      case PLUGIN_ALL_IPA_PASSES_END:
      case PLUGIN_OVERRIDE_GATE:
      case PLUGIN_OVERRIDE_GATE:
      case PLUGIN_PASS_EXECUTION:
      case PLUGIN_PASS_EXECUTION:
      case PLUGIN_EARLY_GIMPLE_PASSES_START:
      case PLUGIN_EARLY_GIMPLE_PASSES_START:
      case PLUGIN_EARLY_GIMPLE_PASSES_END:
      case PLUGIN_EARLY_GIMPLE_PASSES_END:
      case PLUGIN_NEW_PASS:
      case PLUGIN_NEW_PASS:
        {
        {
          /* Iterate over every callback registered with this event and
          /* Iterate over every callback registered with this event and
             call it.  */
             call it.  */
          struct callback_info *callback = plugin_callbacks[event];
          struct callback_info *callback = plugin_callbacks[event];
 
 
          if (!callback)
          if (!callback)
            retval = PLUGEVT_NO_CALLBACK;
            retval = PLUGEVT_NO_CALLBACK;
          for ( ; callback; callback = callback->next)
          for ( ; callback; callback = callback->next)
            (*callback->func) (gcc_data, callback->user_data);
            (*callback->func) (gcc_data, callback->user_data);
        }
        }
        break;
        break;
 
 
      case PLUGIN_PASS_MANAGER_SETUP:
      case PLUGIN_PASS_MANAGER_SETUP:
      case PLUGIN_REGISTER_GGC_ROOTS:
      case PLUGIN_REGISTER_GGC_ROOTS:
      case PLUGIN_REGISTER_GGC_CACHES:
      case PLUGIN_REGISTER_GGC_CACHES:
        gcc_assert (false);
        gcc_assert (false);
    }
    }
 
 
  timevar_pop (TV_PLUGIN_RUN);
  timevar_pop (TV_PLUGIN_RUN);
  return retval;
  return retval;
}
}
 
 
#ifdef ENABLE_PLUGIN
#ifdef ENABLE_PLUGIN
/* We need a union to cast dlsym return value to a function pointer
/* We need a union to cast dlsym return value to a function pointer
   as ISO C forbids assignment between function pointer and 'void *'.
   as ISO C forbids assignment between function pointer and 'void *'.
   Use explicit union instead of __extension__(<union_cast>) for
   Use explicit union instead of __extension__(<union_cast>) for
   portability.  */
   portability.  */
#define PTR_UNION_TYPE(TOTYPE) union { void *_q; TOTYPE _nq; }
#define PTR_UNION_TYPE(TOTYPE) union { void *_q; TOTYPE _nq; }
#define PTR_UNION_AS_VOID_PTR(NAME) (NAME._q)
#define PTR_UNION_AS_VOID_PTR(NAME) (NAME._q)
#define PTR_UNION_AS_CAST_PTR(NAME) (NAME._nq)
#define PTR_UNION_AS_CAST_PTR(NAME) (NAME._nq)
 
 
/* Try to initialize PLUGIN. Return true if successful. */
/* Try to initialize PLUGIN. Return true if successful. */
 
 
static bool
static bool
try_init_one_plugin (struct plugin_name_args *plugin)
try_init_one_plugin (struct plugin_name_args *plugin)
{
{
  void *dl_handle;
  void *dl_handle;
  plugin_init_func plugin_init;
  plugin_init_func plugin_init;
  const char *err;
  const char *err;
  PTR_UNION_TYPE (plugin_init_func) plugin_init_union;
  PTR_UNION_TYPE (plugin_init_func) plugin_init_union;
 
 
  /* We use RTLD_NOW to accelerate binding and detect any mismatch
  /* We use RTLD_NOW to accelerate binding and detect any mismatch
     between the API expected by the plugin and the GCC API; we use
     between the API expected by the plugin and the GCC API; we use
     RTLD_GLOBAL which is useful to plugins which themselves call
     RTLD_GLOBAL which is useful to plugins which themselves call
     dlopen.  */
     dlopen.  */
  dl_handle = dlopen (plugin->full_name, RTLD_NOW | RTLD_GLOBAL);
  dl_handle = dlopen (plugin->full_name, RTLD_NOW | RTLD_GLOBAL);
  if (!dl_handle)
  if (!dl_handle)
    {
    {
      error ("Cannot load plugin %s\n%s", plugin->full_name, dlerror ());
      error ("Cannot load plugin %s\n%s", plugin->full_name, dlerror ());
      return false;
      return false;
    }
    }
 
 
  /* Clear any existing error.  */
  /* Clear any existing error.  */
  dlerror ();
  dlerror ();
 
 
  /* Check the plugin license.  */
  /* Check the plugin license.  */
  if (dlsym (dl_handle, str_license) == NULL)
  if (dlsym (dl_handle, str_license) == NULL)
    fatal_error ("plugin %s is not licensed under a GPL-compatible license\n"
    fatal_error ("plugin %s is not licensed under a GPL-compatible license\n"
                 "%s", plugin->full_name, dlerror ());
                 "%s", plugin->full_name, dlerror ());
 
 
  PTR_UNION_AS_VOID_PTR (plugin_init_union) =
  PTR_UNION_AS_VOID_PTR (plugin_init_union) =
      dlsym (dl_handle, str_plugin_init_func_name);
      dlsym (dl_handle, str_plugin_init_func_name);
  plugin_init = PTR_UNION_AS_CAST_PTR (plugin_init_union);
  plugin_init = PTR_UNION_AS_CAST_PTR (plugin_init_union);
 
 
  if ((err = dlerror ()) != NULL)
  if ((err = dlerror ()) != NULL)
    {
    {
      error ("Cannot find %s in plugin %s\n%s", str_plugin_init_func_name,
      error ("Cannot find %s in plugin %s\n%s", str_plugin_init_func_name,
             plugin->full_name, err);
             plugin->full_name, err);
      return false;
      return false;
    }
    }
 
 
  /* Call the plugin-provided initialization routine with the arguments.  */
  /* Call the plugin-provided initialization routine with the arguments.  */
  if ((*plugin_init) (plugin, &gcc_version))
  if ((*plugin_init) (plugin, &gcc_version))
    {
    {
      error ("Fail to initialize plugin %s", plugin->full_name);
      error ("Fail to initialize plugin %s", plugin->full_name);
      return false;
      return false;
    }
    }
 
 
  return true;
  return true;
}
}
 
 
 
 
/* Routine to dlopen and initialize one plugin. This function is passed to
/* Routine to dlopen and initialize one plugin. This function is passed to
   (and called by) the hash table traverse routine. Return 1 for the
   (and called by) the hash table traverse routine. Return 1 for the
   htab_traverse to continue scan, 0 to stop.
   htab_traverse to continue scan, 0 to stop.
 
 
   SLOT - slot of the hash table element
   SLOT - slot of the hash table element
   INFO - auxiliary pointer handed to hash table traverse routine
   INFO - auxiliary pointer handed to hash table traverse routine
          (unused in this function)  */
          (unused in this function)  */
 
 
static int
static int
init_one_plugin (void **slot, void * ARG_UNUSED (info))
init_one_plugin (void **slot, void * ARG_UNUSED (info))
{
{
  struct plugin_name_args *plugin = (struct plugin_name_args *) *slot;
  struct plugin_name_args *plugin = (struct plugin_name_args *) *slot;
  bool ok = try_init_one_plugin (plugin);
  bool ok = try_init_one_plugin (plugin);
  if (!ok)
  if (!ok)
    {
    {
      htab_remove_elt (plugin_name_args_tab, plugin->base_name);
      htab_remove_elt (plugin_name_args_tab, plugin->base_name);
      XDELETE (plugin);
      XDELETE (plugin);
    }
    }
  return 1;
  return 1;
}
}
 
 
#endif  /* ENABLE_PLUGIN  */
#endif  /* ENABLE_PLUGIN  */
 
 
/* Main plugin initialization function.  Called from compile_file() in
/* Main plugin initialization function.  Called from compile_file() in
   toplev.c.  */
   toplev.c.  */
 
 
void
void
initialize_plugins (void)
initialize_plugins (void)
{
{
  /* If no plugin was specified in the command-line, simply return.  */
  /* If no plugin was specified in the command-line, simply return.  */
  if (!plugin_name_args_tab)
  if (!plugin_name_args_tab)
    return;
    return;
 
 
  timevar_push (TV_PLUGIN_INIT);
  timevar_push (TV_PLUGIN_INIT);
 
 
#ifdef ENABLE_PLUGIN
#ifdef ENABLE_PLUGIN
  /* Traverse and initialize each plugin specified in the command-line.  */
  /* Traverse and initialize each plugin specified in the command-line.  */
  htab_traverse_noresize (plugin_name_args_tab, init_one_plugin, NULL);
  htab_traverse_noresize (plugin_name_args_tab, init_one_plugin, NULL);
#endif
#endif
 
 
  timevar_pop (TV_PLUGIN_INIT);
  timevar_pop (TV_PLUGIN_INIT);
}
}
 
 
/* Release memory used by one plugin. */
/* Release memory used by one plugin. */
 
 
static int
static int
finalize_one_plugin (void **slot, void * ARG_UNUSED (info))
finalize_one_plugin (void **slot, void * ARG_UNUSED (info))
{
{
  struct plugin_name_args *plugin = (struct plugin_name_args *) *slot;
  struct plugin_name_args *plugin = (struct plugin_name_args *) *slot;
  XDELETE (plugin);
  XDELETE (plugin);
  return 1;
  return 1;
}
}
 
 
/* Free memory allocated by the plugin system. */
/* Free memory allocated by the plugin system. */
 
 
void
void
finalize_plugins (void)
finalize_plugins (void)
{
{
  if (!plugin_name_args_tab)
  if (!plugin_name_args_tab)
    return;
    return;
 
 
  /* We can now delete the plugin_name_args object as it will no longer
  /* We can now delete the plugin_name_args object as it will no longer
     be used. Note that base_name and argv fields (both of which were also
     be used. Note that base_name and argv fields (both of which were also
     dynamically allocated) are not freed as they could still be used by
     dynamically allocated) are not freed as they could still be used by
     the plugin code.  */
     the plugin code.  */
 
 
  htab_traverse_noresize (plugin_name_args_tab, finalize_one_plugin, NULL);
  htab_traverse_noresize (plugin_name_args_tab, finalize_one_plugin, NULL);
 
 
  /* PLUGIN_NAME_ARGS_TAB is no longer needed, just delete it.  */
  /* PLUGIN_NAME_ARGS_TAB is no longer needed, just delete it.  */
  htab_delete (plugin_name_args_tab);
  htab_delete (plugin_name_args_tab);
  plugin_name_args_tab = NULL;
  plugin_name_args_tab = NULL;
}
}
 
 
/* Used to pass options to htab_traverse callbacks. */
/* Used to pass options to htab_traverse callbacks. */
 
 
struct print_options
struct print_options
{
{
  FILE *file;
  FILE *file;
  const char *indent;
  const char *indent;
};
};
 
 
/* Print the version of one plugin. */
/* Print the version of one plugin. */
 
 
static int
static int
print_version_one_plugin (void **slot, void *data)
print_version_one_plugin (void **slot, void *data)
{
{
  struct print_options *opt = (struct print_options *) data;
  struct print_options *opt = (struct print_options *) data;
  struct plugin_name_args *plugin = (struct plugin_name_args *) *slot;
  struct plugin_name_args *plugin = (struct plugin_name_args *) *slot;
  const char *version = plugin->version ? plugin->version : "Unknown version.";
  const char *version = plugin->version ? plugin->version : "Unknown version.";
 
 
  fprintf (opt->file, " %s%s: %s\n", opt->indent, plugin->base_name, version);
  fprintf (opt->file, " %s%s: %s\n", opt->indent, plugin->base_name, version);
  return 1;
  return 1;
}
}
 
 
/* Print the version of each plugin. */
/* Print the version of each plugin. */
 
 
void
void
print_plugins_versions (FILE *file, const char *indent)
print_plugins_versions (FILE *file, const char *indent)
{
{
  struct print_options opt;
  struct print_options opt;
  opt.file = file;
  opt.file = file;
  opt.indent = indent;
  opt.indent = indent;
  if (!plugin_name_args_tab || htab_elements (plugin_name_args_tab) == 0)
  if (!plugin_name_args_tab || htab_elements (plugin_name_args_tab) == 0)
    return;
    return;
 
 
  fprintf (file, "%sVersions of loaded plugins:\n", indent);
  fprintf (file, "%sVersions of loaded plugins:\n", indent);
  htab_traverse_noresize (plugin_name_args_tab, print_version_one_plugin, &opt);
  htab_traverse_noresize (plugin_name_args_tab, print_version_one_plugin, &opt);
}
}
 
 
/* Print help for one plugin. SLOT is the hash table slot. DATA is the
/* Print help for one plugin. SLOT is the hash table slot. DATA is the
   argument to htab_traverse_noresize. */
   argument to htab_traverse_noresize. */
 
 
static int
static int
print_help_one_plugin (void **slot, void *data)
print_help_one_plugin (void **slot, void *data)
{
{
  struct print_options *opt = (struct print_options *) data;
  struct print_options *opt = (struct print_options *) data;
  struct plugin_name_args *plugin = (struct plugin_name_args *) *slot;
  struct plugin_name_args *plugin = (struct plugin_name_args *) *slot;
  const char *help = plugin->help ? plugin->help : "No help available .";
  const char *help = plugin->help ? plugin->help : "No help available .";
 
 
  char *dup = xstrdup (help);
  char *dup = xstrdup (help);
  char *p, *nl;
  char *p, *nl;
  fprintf (opt->file, " %s%s:\n", opt->indent, plugin->base_name);
  fprintf (opt->file, " %s%s:\n", opt->indent, plugin->base_name);
 
 
  for (p = nl = dup; nl; p = nl)
  for (p = nl = dup; nl; p = nl)
    {
    {
      nl = strchr (nl, '\n');
      nl = strchr (nl, '\n');
      if (nl)
      if (nl)
        {
        {
          *nl = '\0';
          *nl = '\0';
          nl++;
          nl++;
        }
        }
      fprintf (opt->file, "   %s %s\n", opt->indent, p);
      fprintf (opt->file, "   %s %s\n", opt->indent, p);
    }
    }
 
 
  free (dup);
  free (dup);
  return 1;
  return 1;
}
}
 
 
/* Print help for each plugin. The output goes to FILE and every line starts
/* Print help for each plugin. The output goes to FILE and every line starts
   with INDENT. */
   with INDENT. */
 
 
void
void
print_plugins_help (FILE *file, const char *indent)
print_plugins_help (FILE *file, const char *indent)
{
{
  struct print_options opt;
  struct print_options opt;
  opt.file = file;
  opt.file = file;
  opt.indent = indent;
  opt.indent = indent;
  if (!plugin_name_args_tab || htab_elements (plugin_name_args_tab) == 0)
  if (!plugin_name_args_tab || htab_elements (plugin_name_args_tab) == 0)
    return;
    return;
 
 
  fprintf (file, "%sHelp for the loaded plugins:\n", indent);
  fprintf (file, "%sHelp for the loaded plugins:\n", indent);
  htab_traverse_noresize (plugin_name_args_tab, print_help_one_plugin, &opt);
  htab_traverse_noresize (plugin_name_args_tab, print_help_one_plugin, &opt);
}
}
 
 
 
 
/* Return true if plugins have been loaded.  */
/* Return true if plugins have been loaded.  */
 
 
bool
bool
plugins_active_p (void)
plugins_active_p (void)
{
{
  int event;
  int event;
 
 
  for (event = PLUGIN_PASS_MANAGER_SETUP; event < event_last; event++)
  for (event = PLUGIN_PASS_MANAGER_SETUP; event < event_last; event++)
    if (plugin_callbacks[event])
    if (plugin_callbacks[event])
      return true;
      return true;
 
 
  return false;
  return false;
}
}
 
 
 
 
/* Dump to FILE the names and associated events for all the active
/* Dump to FILE the names and associated events for all the active
   plugins.  */
   plugins.  */
 
 
void
void
dump_active_plugins (FILE *file)
dump_active_plugins (FILE *file)
{
{
  int event;
  int event;
 
 
  if (!plugins_active_p ())
  if (!plugins_active_p ())
    return;
    return;
 
 
  fprintf (file, FMT_FOR_PLUGIN_EVENT " | %s\n", _("Event"), _("Plugins"));
  fprintf (file, FMT_FOR_PLUGIN_EVENT " | %s\n", _("Event"), _("Plugins"));
  for (event = PLUGIN_PASS_MANAGER_SETUP; event < event_last; event++)
  for (event = PLUGIN_PASS_MANAGER_SETUP; event < event_last; event++)
    if (plugin_callbacks[event])
    if (plugin_callbacks[event])
      {
      {
        struct callback_info *ci;
        struct callback_info *ci;
 
 
        fprintf (file, FMT_FOR_PLUGIN_EVENT " |", plugin_event_name[event]);
        fprintf (file, FMT_FOR_PLUGIN_EVENT " |", plugin_event_name[event]);
 
 
        for (ci = plugin_callbacks[event]; ci; ci = ci->next)
        for (ci = plugin_callbacks[event]; ci; ci = ci->next)
          fprintf (file, " %s", ci->plugin_name);
          fprintf (file, " %s", ci->plugin_name);
 
 
        putc('\n', file);
        putc('\n', file);
      }
      }
}
}
 
 
 
 
/* Dump active plugins to stderr.  */
/* Dump active plugins to stderr.  */
 
 
void
void
debug_active_plugins (void)
debug_active_plugins (void)
{
{
  dump_active_plugins (stderr);
  dump_active_plugins (stderr);
}
}
 
 
/* The default version check. Compares every field in VERSION. */
/* The default version check. Compares every field in VERSION. */
 
 
bool
bool
plugin_default_version_check (struct plugin_gcc_version *gcc_version,
plugin_default_version_check (struct plugin_gcc_version *gcc_version,
                              struct plugin_gcc_version *plugin_version)
                              struct plugin_gcc_version *plugin_version)
{
{
  if (!gcc_version || !plugin_version)
  if (!gcc_version || !plugin_version)
    return false;
    return false;
 
 
  if (strcmp (gcc_version->basever, plugin_version->basever))
  if (strcmp (gcc_version->basever, plugin_version->basever))
    return false;
    return false;
  if (strcmp (gcc_version->datestamp, plugin_version->datestamp))
  if (strcmp (gcc_version->datestamp, plugin_version->datestamp))
    return false;
    return false;
  if (strcmp (gcc_version->devphase, plugin_version->devphase))
  if (strcmp (gcc_version->devphase, plugin_version->devphase))
    return false;
    return false;
  if (strcmp (gcc_version->revision, plugin_version->revision))
  if (strcmp (gcc_version->revision, plugin_version->revision))
    return false;
    return false;
  if (strcmp (gcc_version->configuration_arguments,
  if (strcmp (gcc_version->configuration_arguments,
              plugin_version->configuration_arguments))
              plugin_version->configuration_arguments))
    return false;
    return false;
  return true;
  return true;
}
}
 
 
/* Return the current value of event_last, so that plugins which provide
/* Return the current value of event_last, so that plugins which provide
   additional functionality for events for the benefit of high-level plugins
   additional functionality for events for the benefit of high-level plugins
   know how many valid entries plugin_event_name holds.  */
   know how many valid entries plugin_event_name holds.  */
 
 
int
int
get_event_last (void)
get_event_last (void)
{
{
  return event_last;
  return event_last;
}
}
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.