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 <map_hash, T *>::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   typedef int_hash <int, 0, -1> map_hash;
 204
 205   /* Getter for summary callgraph ID.  */
 206   T* get (int uid)
 207   {
 208     bool existed;
 209     T **v = &m_map.get_or_insert (uid, &existed);
 210     if (!existed)
 211       *v = allocate_new ();
 212
 213     return *v;
 214   }
 215
 216   /* Main summary store, where summary ID is used as key.  */
 217   hash_map <map_hash, T *> m_map;
 218   /* Internal summary insertion hook pointer.  */
 219   cgraph_node_hook_list *m_symtab_insertion_hook;
 220   /* Internal summary removal hook pointer.  */
 221   cgraph_node_hook_list *m_symtab_removal_hook;
 222   /* Internal summary duplication hook pointer.  */
 223   cgraph_2node_hook_list *m_symtab_duplication_hook;
 224   /* Indicates if insertion hook is enabled.  */
 225   bool m_insertion_enabled;
 226   /* Symbol table the summary is registered to.  */
 227   symbol_table *m_symtab;
 228
 229   template <typename U> friend void gt_ggc_mx (function_summary <U *> * const &);
 230   template <typename U> friend void gt_pch_nx (function_summary <U *> * const &);
 231   template <typename U> friend void gt_pch_nx (function_summary <U *> * const &,
 232       gt_pointer_operator, void *);
 233 };
 234
 235 template <typename T>
 236 void
 237 gt_ggc_mx(function_summary<T *>* const &summary)
 238 {
 239   gcc_checking_assert (summary->m_ggc);
 240   gt_ggc_mx (&summary->m_map);
 241 }
 242
 243 template <typename T>
 244 void
 245 gt_pch_nx(function_summary<T *>* const &summary)
 246 {
 247   gcc_checking_assert (summary->m_ggc);
 248   gt_pch_nx (&summary->m_map);
 249 }
 250
 251 template <typename T>
 252 void
 253 gt_pch_nx(function_summary<T *>* const& summary, gt_pointer_operator op,
 254           void *cookie)
 255 {
 256   gcc_checking_assert (summary->m_ggc);
 257   gt_pch_nx (&summary->m_map, op, cookie);
 258 }
 259
 260 #endif  /* GCC_SYMBOL_SUMMARY_H  */