gcc/symbol-summary.h

   1 /* Callgraph summary data structure.
   2    Copyright (C) 2014-2015 Free Software Foundation, Inc.
   3    Contributed by Martin Liska
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 3, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.  */
  20
  21 #ifndef GCC_SYMBOL_SUMMARY_H
  22 #define GCC_SYMBOL_SUMMARY_H
  23
  24 /* We want to pass just pointer types as argument for function_summary
  25    template class.  */
  26
  27 template <class T>
  28 class function_summary
  29 {
  30 private:
  31   function_summary();
  32 };
  33
  34 template <class T>
  35 class GTY((user)) function_summary <T *>
  36 {
  37 public:
  38   /* Default construction takes SYMTAB as an argument.  */
  39   function_summary (symbol_table *symtab, bool ggc = false): m_ggc (ggc),
  40     m_map (13, ggc), m_insertion_enabled (true), m_symtab (symtab)
  41   {
  42 #ifdef ENABLE_CHECKING
  43     cgraph_node *node;
  44
  45     FOR_EACH_FUNCTION (node)
  46     {
  47       gcc_checking_assert (node->summary_uid > 0);
  48     }
  49 #endif
  50
  51     m_symtab_insertion_hook =
  52       symtab->add_cgraph_insertion_hook
  53       (function_summary::symtab_insertion, this);
  54
  55     m_symtab_removal_hook =
  56       symtab->add_cgraph_removal_hook
  57       (function_summary::symtab_removal, this);
  58     m_symtab_duplication_hook =
  59       symtab->add_cgraph_duplication_hook
  60       (function_summary::symtab_duplication, this);
  61   }
  62
  63   /* Destructor.  */
  64   virtual ~function_summary ()
  65   {
  66     release ();
  67   }
  68
  69   /* Destruction method that can be called for GGT purpose.  */
  70   void release ()
  71   {
  72     if (m_symtab_insertion_hook)
  73       m_symtab->remove_cgraph_insertion_hook (m_symtab_insertion_hook);
  74
  75     if (m_symtab_removal_hook)
  76       m_symtab->remove_cgraph_removal_hook (m_symtab_removal_hook);
  77
  78     if (m_symtab_duplication_hook)
  79       m_symtab->remove_cgraph_duplication_hook (m_symtab_duplication_hook);
  80
  81     m_symtab_insertion_hook = NULL;
  82     m_symtab_removal_hook = NULL;
  83     m_symtab_duplication_hook = NULL;
  84
  85     /* Release all summaries.  */
  86     typedef typename hash_map <int, T *, summary_hashmap_traits>::iterator map_iterator;
  87     for (map_iterator it = m_map.begin (); it != m_map.end (); ++it)
  88       release ((*it).second);
  89   }
  90
  91   /* Traverses all summarys with a function F called with
  92      ARG as argument.  */
  93   template<typename Arg, bool (*f)(const T &, Arg)>
  94   void traverse (Arg a) const
  95   {
  96     m_map.traverse <f> (a);
  97   }
  98
  99   /* Basic implementation of insert operation.  */
 100   virtual void insert (cgraph_node *, T *) {}
 101
 102   /* Basic implementation of removal operation.  */
 103   virtual void remove (cgraph_node *, T *) {}
 104
 105   /* Basic implementation of duplication operation.  */
 106   virtual void duplicate (cgraph_node *, cgraph_node *, T *, T *) {}
 107
 108   /* Allocates new data that are stored within map.  */
 109   T* allocate_new ()
 110   {
 111     return m_ggc ? new (ggc_alloc <T> ()) T() : new T () ;
 112   }
 113
 114   /* Release an item that is stored within map.  */
 115   void release (T *item)
 116   {
 117     if (m_ggc)
 118       {
 119         item->~T ();
 120         ggc_free (item);
 121       }
 122     else
 123       delete item;
 124   }
 125
 126   /* Getter for summary callgraph node pointer.  */
 127   T* get (cgraph_node *node)
 128   {
 129     return get (node->summary_uid);
 130   }
 131
 132   /* Return number of elements handled by data structure.  */
 133   size_t elements ()
 134   {
 135     return m_map.elements ();
 136   }
 137
 138   /* Enable insertion hook invocation.  */
 139   void enable_insertion_hook ()
 140   {
 141     m_insertion_enabled = true;
 142   }
 143
 144   /* Enable insertion hook invocation.  */
 145   void disable_insertion_hook ()
 146   {
 147     m_insertion_enabled = false;
 148   }
 149
 150   /* Symbol insertion hook that is registered to symbol table.  */
 151   static void symtab_insertion (cgraph_node *node, void *data)
 152   {
 153     function_summary *summary = (function_summary <T *> *) (data);
 154
 155     if (summary->m_insertion_enabled)
 156       summary->insert (node, summary->get (node));
 157   }
 158
 159   /* Symbol removal hook that is registered to symbol table.  */
 160   static void symtab_removal (cgraph_node *node, void *data)
 161   {
 162     gcc_checking_assert (node->summary_uid);
 163     function_summary *summary = (function_summary <T *> *) (data);
 164
 165     int summary_uid = node->summary_uid;
 166     T **v = summary->m_map.get (summary_uid);
 167
 168     if (v)
 169       {
 170         summary->remove (node, *v);
 171
 172         if (!summary->m_ggc)
 173           delete (*v);
 174
 175         summary->m_map.remove (summary_uid);
 176       }
 177   }
 178
 179   /* Symbol duplication hook that is registered to symbol table.  */
 180   static void symtab_duplication (cgraph_node *node, cgraph_node *node2,
 181                                   void *data)
 182   {
 183     function_summary *summary = (function_summary <T *> *) (data);
 184     T **v = summary->m_map.get (node->summary_uid);
 185
 186     gcc_checking_assert (node2->summary_uid > 0);
 187
 188     if (v)
 189       {
 190         /* This load is necessary, because we insert a new value!  */
 191         T *data = *v;
 192         T *duplicate = summary->allocate_new ();
 193         summary->m_map.put (node2->summary_uid, duplicate);
 194         summary->duplicate (node, node2, data, duplicate);
 195       }
 196   }
 197
 198 protected:
 199   /* Indication if we use ggc summary.  */
 200   bool m_ggc;
 201
 202 private:
 203   struct summary_hashmap_traits: default_hashmap_traits
 204   {
 205     static const int deleted_value = -1;
 206     static const int empty_value = 0;
 207
 208     static hashval_t
 209     hash (const int v)
 210     {
 211       return (hashval_t)v;
 212     }
 213
 214     template<typename Type>
 215     static bool
 216     is_deleted (Type &e)
 217     {
 218       return e.m_key == deleted_value;
 219     }
 220
 221     template<typename Type>
 222     static bool
 223     is_empty (Type &e)
 224     {
 225       return e.m_key == empty_value;
 226     }
 227
 228     template<typename Type>
 229     static void
 230     mark_deleted (Type &e)
 231     {
 232       e.m_key = deleted_value;
 233     }
 234
 235     template<typename Type>
 236     static void
 237     mark_empty (Type &e)
 238     {
 239       e.m_key = empty_value;
 240     }
 241   };
 242
 243   /* Getter for summary callgraph ID.  */
 244   T* get (int uid)
 245   {
 246     bool existed;
 247     T **v = &m_map.get_or_insert (uid, &existed);
 248     if (!existed)
 249       *v = allocate_new ();
 250
 251     return *v;
 252   }
 253
 254   /* Main summary store, where summary ID is used as key.  */
 255   hash_map <int, T *, summary_hashmap_traits> m_map;
 256   /* Internal summary insertion hook pointer.  */
 257   cgraph_node_hook_list *m_symtab_insertion_hook;
 258   /* Internal summary removal hook pointer.  */
 259   cgraph_node_hook_list *m_symtab_removal_hook;
 260   /* Internal summary duplication hook pointer.  */
 261   cgraph_2node_hook_list *m_symtab_duplication_hook;
 262   /* Indicates if insertion hook is enabled.  */
 263   bool m_insertion_enabled;
 264   /* Symbol table the summary is registered to.  */
 265   symbol_table *m_symtab;
 266
 267   template <typename U> friend void gt_ggc_mx (function_summary <U *> * const &);
 268   template <typename U> friend void gt_pch_nx (function_summary <U *> * const &);
 269   template <typename U> friend void gt_pch_nx (function_summary <U *> * const &,
 270       gt_pointer_operator, void *);
 271 };
 272
 273 template <typename T>
 274 void
 275 gt_ggc_mx(function_summary<T *>* const &summary)
 276 {
 277   gcc_checking_assert (summary->m_ggc);
 278   gt_ggc_mx (&summary->m_map);
 279 }
 280
 281 template <typename T>
 282 void
 283 gt_pch_nx(function_summary<T *>* const &summary)
 284 {
 285   gcc_checking_assert (summary->m_ggc);
 286   gt_pch_nx (&summary->m_map);
 287 }
 288
 289 template <typename T>
 290 void
 291 gt_pch_nx(function_summary<T *>* const& summary, gt_pointer_operator op,
 292           void *cookie)
 293 {
 294   gcc_checking_assert (summary->m_ggc);
 295   gt_pch_nx (&summary->m_map, op, cookie);
 296 }
 297
 298 #endif  /* GCC_SYMBOL_SUMMARY_H  */