gcc/ici/events.c

   1 /* High-level event callback mechanism for GCC plugins.
   2    Copyright (C) 2009 Free Software Foundation, Inc.
   3
   4    Contributed by Inria.
   5
   6    Authors: Grigori Fursin <grigori.fursin@inria.fr>, Cupertino Miranda
   7    <cupertinomiranda@gmail.com>, Zbigniew Chamski <zbigniew.chamski@gmail.com>.
   8
   9 This file is part of GCC.
  10
  11 GCC is free software; you can redistribute it and/or modify it under
  12 the terms of the GNU General Public License as published by the Free
  13 Software Foundation; either version 3, or (at your option) any later
  14 version.
  15
  16 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  17 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19 for more details.
  20
  21 You should have received a copy of the GNU General Public License
  22 along with GCC; see the file COPYING3.  If not see
  23 <http://www.gnu.org/licenses/>.  */
  24
  25 #include "config.h"
  26 #include "system.h"
  27 #include "coretypes.h"
  28 #include "hashtab.h"
  29 #include "toplev.h"
  30 #include "gcc-plugin.h"
  31 #include "tree-pass.h"
  32
  33 #include "highlev-plugin-internal.h"
  34
  35 /* Event structure.  */
  36 struct hl_plugin_event
  37 {
  38   event_callback_t run;         /* Callback function */
  39   const char *param_name;
  40 };
  41
  42
  43 /* Parameter structure.  */
  44 struct event_parameter
  45 {
  46   const char *name;             /* Name for the parameter */
  47   void *value;                  /* Pointer to data */
  48   event_parameter_type type;    /* Type enumeration of value */
  49 };
  50
  51
  52 static htab_t parameters_hash = NULL;
  53
  54
  55 /* Hash dependent functions.  */
  56 static hashval_t
  57 string_htab_hash (const void *x)
  58 {
  59   const char *p = *((const char * const *) x);
  60
  61   if (p != NULL)
  62     return htab_hash_string (p);
  63
  64   return 0;
  65 }
  66
  67
  68 static int
  69 string_htab_eq (const void *x, const void *y)
  70 {
  71   const char *s1 = *((const char * const *) x);
  72   const char *s2 = *((const char * const *) y);
  73
  74   return !strcmp (s1, s2);
  75 }
  76
  77
  78 static void
  79 parameter_htab_del (void *p)
  80 {
  81   struct parameter *param = (struct parameter *) p;
  82   free (param);
  83 }
  84
  85
  86 static void
  87 hash_param_callback (void *gcc_data, void *user_data)
  88 {
  89   struct hl_plugin_event *ev = (struct hl_plugin_event *) user_data;
  90   va_list va;
  91   const char *name;
  92   int type;
  93   void *value;
  94
  95   if (gcc_data != NULL)
  96     {
  97       /* Possible extension:
  98          Might interpret gcc_data differently for specific values of
  99          ev->event, e.g. we could get a struct loop and put all the
 100          struct members in named parameters.  */
 101       va_copy (va, * (va_list *) gcc_data);
 102
 103       while ((name = va_arg (va, const char *)) != NULL)
 104         {
 105           type = va_arg (va, int);
 106           value = va_arg (va, void *);
 107           register_event_parameter (name, value,
 108                                     (event_parameter_type) type);
 109         }
 110       va_end (va);
 111     }
 112   ev->run ();
 113   va_copy (va, * (va_list *) gcc_data);
 114   while ((name = va_arg (va, const char *)) != NULL)
 115     {
 116       unregister_event_parameter (name);
 117       va_arg (va, void *);
 118     }
 119 }
 120
 121 static void
 122 status_callback (void *gcc_data, void *user_data)
 123 {
 124   struct hl_plugin_event *ev = (struct hl_plugin_event *) user_data;
 125
 126   register_event_parameter (ev->param_name, gcc_data, EP_INT);
 127   ev->run ();
 128   unregister_event_parameter (ev->param_name);
 129 }
 130
 131 static void
 132 pass_execution_callback (void *gcc_data, void *user_data)
 133 {
 134   struct hl_plugin_event *ev = (struct hl_plugin_event *) user_data;
 135   struct opt_pass *pass = (struct opt_pass *) gcc_data;
 136
 137   register_event_parameter ("_pass_type", &(pass->type), EP_INT);
 138   ev->run ();
 139   unregister_event_parameter ("_pass_type");
 140 }
 141
 142 /* Register a new event into hash table.  */
 143 void
 144 register_plugin_event (const char *event_name, event_callback_t func)
 145 {
 146   int event;
 147   struct hl_plugin_event *ev = XCNEW (struct hl_plugin_event);
 148
 149   if (event_name == NULL)
 150     internal_error ("Event cannot be registered with NULL name string\n");
 151
 152   event = get_named_event_id (event_name, INSERT);
 153   ev->run = func;
 154   switch (event)
 155     {
 156     case PLUGIN_ALL_IPA_PASSES_EXECUTION:
 157     case PLUGIN_ALL_PASSES_EXECUTION:
 158       ev->param_name = "substitute_status";
 159       register_callback ("ICI", event, status_callback, ev);
 160       break;
 161     case PLUGIN_AVOID_GATE:
 162       ev->param_name = "gate_status";
 163       register_callback ("ICI", event, status_callback, ev);
 164       break;
 165     case PLUGIN_PASS_EXECUTION:
 166       register_callback ("ICI", event, pass_execution_callback, ev);
 167       break;
 168     default:
 169       register_callback ("ICI", event, hash_param_callback, ev);
 170     }
 171   ici_refresh_internal_callbacks (event);
 172 }
 173
 174
 175 /* Unregister an event.  */
 176 void
 177 unregister_plugin_event (const char *event_name)
 178 {
 179   int event = get_named_event_id (event_name, NO_INSERT);
 180
 181   if (event < 0)
 182     return;
 183
 184   unregister_callback ("ICI", event);
 185 }
 186
 187
 188 /* Return the array of all event names, terminated by NULL.  */
 189 const char **
 190 list_plugin_events (void)
 191 {
 192   int i;
 193
 194   /* allocate space for all names + the terminating NULL */
 195   const char **all_events = XNEWVEC (const char *, (event_last + 1));
 196
 197   /* collect all event names */
 198   for (i = 0; i < event_last; i++)
 199     all_events[i] = plugin_event_name[i];
 200
 201   /* mark end-of-array */
 202   all_events[i] = NULL;
 203
 204   return all_events;
 205 }
 206
 207
 208 /* Register parameter.
 209  * Insert parameter into hash table. Allocates hash table
 210  * if needed.  */
 211 void
 212 register_event_parameter (const char *name, void* value,
 213                           event_parameter_type type)
 214 {
 215   void **slot;
 216   struct event_parameter *param = XCNEW (struct event_parameter);
 217
 218   param->name = name;
 219   param->value = value;
 220   param->type = type;
 221
 222   if (param->name == NULL || !strcmp ("", param->name))
 223     internal_error ("Parameter cannot be registered with NULL name string\n");
 224
 225   if (parameters_hash == NULL)
 226     parameters_hash =
 227       htab_create_alloc (150, string_htab_hash,
 228                          string_htab_eq, parameter_htab_del, xcalloc, free);
 229
 230   if (parameters_hash != NULL)
 231     {
 232       slot = htab_find_slot (parameters_hash, param, INSERT);
 233       *slot = (void *) param;
 234     }
 235 }
 236
 237
 238 /* Unregister parameter. Remove it from hash table.  */
 239 void
 240 unregister_event_parameter (const char *name)
 241 {
 242   struct event_parameter param;
 243   param.name = name;
 244
 245   if (parameters_hash == NULL)
 246     internal_error ("Parameter hash not initialized.\n");
 247
 248   if (parameters_hash != NULL)
 249     htab_remove_elt (parameters_hash, &param);
 250 }
 251
 252
 253 /* Get parameter pointer to data.
 254    Used by plugin to get pointer to data of the parameter <name>.  */
 255 void *
 256 get_event_parameter (const char *name)
 257 {
 258   struct event_parameter tmp_param, *param;
 259   tmp_param.name = name;
 260
 261   if (parameters_hash == NULL)
 262     internal_error ("Parameter hash not initialized.\n");
 263
 264   if (parameters_hash != NULL)
 265     {
 266       param = (struct event_parameter *)
 267         htab_find (parameters_hash, &tmp_param);
 268
 269       if (param != NULL && param->value != NULL)
 270         return param->value;
 271     }
 272   return NULL;
 273 }
 274
 275 /* Get parameter type.
 276    Used by plugin to get type of data pointer of the parameter <name>.  */
 277 event_parameter_type
 278 get_event_parameter_type (const char *name)
 279 {
 280   struct event_parameter tmp_param, *param;
 281   tmp_param.name = name;
 282
 283   if (parameters_hash == NULL)
 284     internal_error ("Parameter hash not initialized.\n");
 285
 286   if (parameters_hash != NULL)
 287     {
 288       param = (struct event_parameter *)
 289         htab_find (parameters_hash, &tmp_param);
 290
 291       if (param != NULL && param->value != NULL)
 292         return param->type;
 293     }
 294   return EP_VOID;
 295 }
 296
 297 /* Get list of names of all registered ICI parameters.
 298  * Traverse the hash table collecting the names of entries.
 299  */
 300 static int
 301 add_parameter_name (void **slot, void *data)
 302 {
 303   const char ***crnt_name_ptr = (const char ***) data;
 304   struct event_parameter *parameter = *(struct event_parameter **) slot;
 305
 306   /* store the name of the current parameter at the corresponding
 307      location */
 308   **crnt_name_ptr = parameter->name;
 309
 310   /* advance the current location */
 311   (*crnt_name_ptr)++;
 312
 313   /* return "OK" */
 314   return 1;
 315 }
 316
 317
 318 /* return the array of all parameter names, terminated by NULL */
 319 const char **
 320 list_event_parameters (void)
 321 {
 322   size_t num_parameters = htab_elements (parameters_hash);
 323
 324   /* allocate space for all names + the terminating NULL */
 325   const char **all_parameters = (const char **)
 326     xmalloc (sizeof (const char *) * (num_parameters+1));
 327
 328   const char ***data = &all_parameters; /* data ptr for mapped function */
 329   const char **first_parameter = all_parameters; /* keep track of actual start */
 330
 331   /* mark end-of-array */
 332   all_parameters[num_parameters] = NULL;
 333
 334   /* collect all parameter names */
 335   htab_traverse_noresize (parameters_hash, add_parameter_name, data);
 336
 337   /* use the stored start-of-array - all_parameters has changed during
 338      htab_traverse_noresize */
 339   return first_parameter;
 340 }