#ifndef GCC_SYMBOL_SUMMARY_H
#define GCC_SYMBOL_SUMMARY_H
+/* Base class for function_summary and fast_function_summary classes. */
+
+template <class T>
+class function_summary_base
+{
+public:
+ /* Default construction takes SYMTAB as an argument. */
+ function_summary_base (symbol_table *symtab): m_symtab (symtab),
+ m_insertion_enabled (true), m_released (false)
+ {}
+
+ /* Basic implementation of insert operation. */
+ virtual void insert (cgraph_node *, T *) {}
+
+ /* Basic implementation of removal operation. */
+ virtual void remove (cgraph_node *, T *) {}
+
+ /* Basic implementation of duplication operation. */
+ virtual void duplicate (cgraph_node *, cgraph_node *, T *, T *) {}
+
+ /* Enable insertion hook invocation. */
+ void enable_insertion_hook ()
+ {
+ m_insertion_enabled = true;
+ }
+
+ /* Enable insertion hook invocation. */
+ void disable_insertion_hook ()
+ {
+ m_insertion_enabled = false;
+ }
+
+protected:
+ /* Allocates new data that are stored within map. */
+ T* allocate_new ()
+ {
+ /* Call gcc_internal_because we do not want to call finalizer for
+ a type T. We call dtor explicitly. */
+ return is_ggc () ? new (ggc_internal_alloc (sizeof (T))) T () : new T () ;
+ }
+
+ /* Release an item that is stored within map. */
+ void release (T *item)
+ {
+ if (is_ggc ())
+ {
+ item->~T ();
+ ggc_free (item);
+ }
+ else
+ delete item;
+ }
+
+ /* Unregister all call-graph hooks. */
+ void unregister_hooks ();
+
+ /* Internal summary insertion hook pointer. */
+ cgraph_node_hook_list *m_symtab_insertion_hook;
+ /* Internal summary removal hook pointer. */
+ cgraph_node_hook_list *m_symtab_removal_hook;
+ /* Internal summary duplication hook pointer. */
+ cgraph_2node_hook_list *m_symtab_duplication_hook;
+ /* Symbol table the summary is registered to. */
+ symbol_table *m_symtab;
+
+ /* Indicates if insertion hook is enabled. */
+ bool m_insertion_enabled;
+ /* Indicates if the summary is released. */
+ bool m_released;
+
+private:
+ /* Return true when the summary uses GGC memory for allocation. */
+ virtual bool is_ggc () = 0;
+};
+
+template <typename T>
+void
+function_summary_base<T>::unregister_hooks ()
+{
+ m_symtab->remove_cgraph_insertion_hook (m_symtab_insertion_hook);
+ m_symtab->remove_cgraph_removal_hook (m_symtab_removal_hook);
+ m_symtab->remove_cgraph_duplication_hook (m_symtab_duplication_hook);
+}
+
/* We want to pass just pointer types as argument for function_summary
template class. */
a memory gained by garbage collected memory. */
template <class T>
-class GTY((user)) function_summary <T *>
+class GTY((user)) function_summary <T *>: public function_summary_base<T>
{
public:
/* Default construction takes SYMTAB as an argument. */
release ();
}
- /* Destruction method that can be called for GGT purpose. */
+ /* Destruction method that can be called for GGC purpose. */
+ using function_summary_base<T>::release;
void release ();
/* Traverses all summarys with a function F called with
m_map.traverse <f> (a);
}
- /* Basic implementation of insert operation. */
- virtual void insert (cgraph_node *, T *) {}
-
- /* Basic implementation of removal operation. */
- virtual void remove (cgraph_node *, T *) {}
-
- /* Basic implementation of duplication operation. */
- virtual void duplicate (cgraph_node *, cgraph_node *, T *, T *) {}
-
- /* Allocates new data that are stored within map. */
- T* allocate_new ()
- {
- /* Call gcc_internal_because we do not want to call finalizer for
- a type T. We call dtor explicitly. */
- return m_ggc ? new (ggc_internal_alloc (sizeof (T))) T () : new T () ;
- }
-
- /* Release an item that is stored within map. */
- void release (T *item);
-
/* Getter for summary callgraph node pointer. If a summary for a node
does not exist it will be created. */
T* get_create (cgraph_node *node)
bool existed;
T **v = &m_map.get_or_insert (node->get_uid (), &existed);
if (!existed)
- *v = allocate_new ();
+ *v = this->allocate_new ();
return *v;
}
}
/* Remove node from summary. */
+ using function_summary_base<T>::remove;
void remove (cgraph_node *node)
{
int uid = node->get_uid ();
if (v)
{
m_map.remove (uid);
- release (*v);
+ this->release (*v);
}
}
- /* Return number of elements handled by data structure. */
- size_t elements ()
- {
- return m_map.elements ();
- }
-
/* Return true if a summary for the given NODE already exists. */
bool exists (cgraph_node *node)
{
return m_map.get (node->get_uid ()) != NULL;
}
- /* Enable insertion hook invocation. */
- void enable_insertion_hook ()
- {
- m_insertion_enabled = true;
- }
-
- /* Enable insertion hook invocation. */
- void disable_insertion_hook ()
- {
- m_insertion_enabled = false;
- }
-
/* Symbol insertion hook that is registered to symbol table. */
static void symtab_insertion (cgraph_node *node, void *data);
bool m_ggc;
private:
+ /* Indication if we use ggc summary. */
+ virtual bool is_ggc ()
+ {
+ return m_ggc;
+ }
+
typedef int_hash <int, 0, -1> map_hash;
- /* Indicates if insertion hook is enabled. */
- bool m_insertion_enabled;
- /* Indicates if the summary is released. */
- bool m_released;
/* Main summary store, where summary ID is used as key. */
hash_map <map_hash, T *> m_map;
- /* Internal summary insertion hook pointer. */
- cgraph_node_hook_list *m_symtab_insertion_hook;
- /* Internal summary removal hook pointer. */
- cgraph_node_hook_list *m_symtab_removal_hook;
- /* Internal summary duplication hook pointer. */
- cgraph_2node_hook_list *m_symtab_duplication_hook;
- /* Symbol table the summary is registered to. */
- symbol_table *m_symtab;
template <typename U> friend void gt_ggc_mx (function_summary <U *> * const &);
template <typename U> friend void gt_pch_nx (function_summary <U *> * const &);
template <typename T>
function_summary<T *>::function_summary (symbol_table *symtab, bool ggc):
- m_ggc (ggc), m_insertion_enabled (true), m_released (false), m_map (13, ggc),
- m_symtab (symtab)
+ function_summary_base<T> (symtab), m_ggc (ggc), m_map (13, ggc)
{
- m_symtab_insertion_hook
- = symtab->add_cgraph_insertion_hook (function_summary::symtab_insertion,
- this);
-
- m_symtab_removal_hook
- = symtab->add_cgraph_removal_hook (function_summary::symtab_removal, this);
- m_symtab_duplication_hook
- = symtab->add_cgraph_duplication_hook (function_summary::symtab_duplication,
- this);
+ this->m_symtab_insertion_hook
+ = this->m_symtab->add_cgraph_insertion_hook (function_summary::symtab_insertion,
+ this);
+ this->m_symtab_removal_hook
+ = this->m_symtab->add_cgraph_removal_hook (function_summary::symtab_removal,
+ this);
+ this->m_symtab_duplication_hook
+ = this->m_symtab->add_cgraph_duplication_hook (function_summary::symtab_duplication,
+ this);
}
template <typename T>
void
function_summary<T *>::release ()
{
- if (m_released)
+ if (this->m_released)
return;
- m_symtab->remove_cgraph_insertion_hook (m_symtab_insertion_hook);
- m_symtab->remove_cgraph_removal_hook (m_symtab_removal_hook);
- m_symtab->remove_cgraph_duplication_hook (m_symtab_duplication_hook);
+ this->unregister_hooks ();
/* Release all summaries. */
typedef typename hash_map <map_hash, T *>::iterator map_iterator;
for (map_iterator it = m_map.begin (); it != m_map.end (); ++it)
- release ((*it).second);
+ this->release ((*it).second);
- m_released = true;
-}
-
-template <typename T>
-void
-function_summary<T *>::release (T *item)
-{
- if (m_ggc)
- {
- item->~T ();
- ggc_free (item);
- }
- else
- delete item;
+ this->m_released = true;
}
template <typename T>
{
gcc_checking_assert (node->get_uid ());
function_summary *summary = (function_summary <T *> *) (data);
-
- int uid = node->get_uid ();
- T **v = summary->m_map.get (uid);
-
- if (v)
- {
- summary->remove (node, *v);
-
- if (!summary->m_ggc)
- delete (*v);
-
- summary->m_map.remove (uid);
- }
+ summary->remove (node);
}
template <typename T>
T *v = summary->get (node);
if (v)
- {
- /* This load is necessary, because we insert a new value! */
- T *duplicate = summary->allocate_new ();
- summary->m_map.put (node2->get_uid (), duplicate);
- summary->duplicate (node, node2, v, duplicate);
- }
+ summary->duplicate (node, node2, v, summary->get_create (node2));
}
template <typename T>
gt_pch_nx (&summary->m_map, op, cookie);
}
-/* An impossible class templated by non-pointers so, which makes sure that only
- summaries gathering pointers can be created. */
+/* Help template from std c++11. */
-template <class T>
-class call_summary
+template<typename T, typename U>
+struct is_same
+{
+ static const bool value = false;
+};
+
+template<typename T>
+struct is_same<T,T> //specialization
+{
+ static const bool value = true;
+};
+
+/* We want to pass just pointer types as argument for fast_function_summary
+ template class. */
+
+template <class T, class V>
+class fast_function_summary
{
private:
- call_summary();
+ fast_function_summary ();
};
-/* Class to store auxiliary information about call graph edges. */
+/* Function vector summary is a fast implementation of function_summary that
+ utilizes vector as primary storage of summaries. */
-template <class T>
-class GTY((user)) call_summary <T *>
+template <class T, class V>
+class GTY((user)) fast_function_summary <T *, V>
+ : public function_summary_base<T>
{
public:
/* Default construction takes SYMTAB as an argument. */
- call_summary (symbol_table *symtab, bool ggc = false): m_ggc (ggc),
- m_initialize_when_cloning (false), m_map (13, ggc), m_released (false),
- m_symtab (symtab)
- {
- m_symtab_removal_hook =
- symtab->add_edge_removal_hook
- (call_summary::symtab_removal, this);
- m_symtab_duplication_hook =
- symtab->add_edge_duplication_hook
- (call_summary::symtab_duplication, this);
- }
+ fast_function_summary (symbol_table *symtab);
/* Destructor. */
- virtual ~call_summary ()
+ virtual ~fast_function_summary ()
{
release ();
}
- /* Destruction method that can be called for GGT purpose. */
+ /* Destruction method that can be called for GGC purpose. */
+ using function_summary_base<T>::release;
void release ();
/* Traverses all summarys with a function F called with
template<typename Arg, bool (*f)(const T &, Arg)>
void traverse (Arg a) const
{
- m_map.traverse <f> (a);
+ for (unsigned i = 0; i < m_vector->length (); i++)
+ if ((*m_vector[i]) != NULL)
+ f ((*m_vector)[i]);
+ }
+
+ /* Getter for summary callgraph node pointer. If a summary for a node
+ does not exist it will be created. */
+ T* get_create (cgraph_node *node)
+ {
+ int id = node->get_summary_id ();
+ if (id == -1)
+ id = this->m_symtab->assign_summary_id (node);
+
+ if ((unsigned int)id >= m_vector->length ())
+ vec_safe_grow_cleared (m_vector,
+ this->m_symtab->cgraph_max_summary_id);
+
+ if ((*m_vector)[id] == NULL)
+ (*m_vector)[id] = this->allocate_new ();
+
+ return (*m_vector)[id];
+ }
+
+ /* Getter for summary callgraph node pointer. */
+ T* get (cgraph_node *node) ATTRIBUTE_PURE
+ {
+ return exists (node) ? (*m_vector)[node->get_summary_id ()] : NULL;
}
+ using function_summary_base<T>::remove;
+ void remove (cgraph_node *node)
+ {
+ if (exists (node))
+ {
+ int id = node->get_summary_id ();
+ this->release ((*m_vector)[id]);
+ (*m_vector)[id] = NULL;
+ }
+ }
+
+ /* Return true if a summary for the given NODE already exists. */
+ bool exists (cgraph_node *node)
+ {
+ int id = node->get_summary_id ();
+ return (id != -1
+ && (unsigned int)id < m_vector->length ()
+ && (*m_vector)[id] != NULL);
+ }
+
+ /* Symbol insertion hook that is registered to symbol table. */
+ static void symtab_insertion (cgraph_node *node, void *data);
+
+ /* Symbol removal hook that is registered to symbol table. */
+ static void symtab_removal (cgraph_node *node, void *data);
+
+ /* Symbol duplication hook that is registered to symbol table. */
+ static void symtab_duplication (cgraph_node *node, cgraph_node *node2,
+ void *data);
+
+private:
+ virtual bool is_ggc ();
+
+ /* Summary is stored in the vector. */
+ vec <T *, V> *m_vector;
+
+ template <typename U> friend void gt_ggc_mx (fast_function_summary <U *, va_gc> * const &);
+ template <typename U> friend void gt_pch_nx (fast_function_summary <U *, va_gc> * const &);
+ template <typename U> friend void gt_pch_nx (fast_function_summary <U *, va_gc> * const &,
+ gt_pointer_operator, void *);
+};
+
+template <typename T, typename V>
+fast_function_summary<T *, V>::fast_function_summary (symbol_table *symtab):
+ function_summary_base<T> (symtab), m_vector (NULL)
+{
+ vec_alloc (m_vector, 13);
+ this->m_symtab_insertion_hook
+ = this->m_symtab->add_cgraph_insertion_hook (fast_function_summary::symtab_insertion,
+ this);
+ this->m_symtab_removal_hook
+ = this->m_symtab->add_cgraph_removal_hook (fast_function_summary::symtab_removal,
+ this);
+ this->m_symtab_duplication_hook
+ = this->m_symtab->add_cgraph_duplication_hook (fast_function_summary::symtab_duplication,
+ this);
+}
+
+template <typename T, typename V>
+void
+fast_function_summary<T *, V>::release ()
+{
+ if (this->m_released)
+ return;
+
+ this->unregister_hooks ();
+
+ /* Release all summaries. */
+ for (unsigned i = 0; i < m_vector->length (); i++)
+ if ((*m_vector)[i] != NULL)
+ this->release ((*m_vector)[i]);
+
+ this->m_released = true;
+}
+
+template <typename T, typename V>
+void
+fast_function_summary<T *, V>::symtab_insertion (cgraph_node *node, void *data)
+{
+ gcc_checking_assert (node->get_uid ());
+ fast_function_summary *summary = (fast_function_summary <T *, V> *) (data);
+
+ if (summary->m_insertion_enabled)
+ summary->insert (node, summary->get_create (node));
+}
+
+template <typename T, typename V>
+void
+fast_function_summary<T *, V>::symtab_removal (cgraph_node *node, void *data)
+{
+ gcc_checking_assert (node->get_uid ());
+ fast_function_summary *summary = (fast_function_summary <T *, V> *) (data);
+
+ if (summary->exists (node))
+ summary->remove (node);
+}
+
+template <typename T, typename V>
+void
+fast_function_summary<T *, V>::symtab_duplication (cgraph_node *node,
+ cgraph_node *node2,
+ void *data)
+{
+ fast_function_summary *summary = (fast_function_summary <T *, V> *) (data);
+ T *v = summary->get (node);
+
+ if (v)
+ {
+ T *duplicate = summary->get_create (node2);
+ summary->duplicate (node, node2, v, duplicate);
+ }
+}
+
+template <typename T, typename V>
+inline bool
+fast_function_summary<T *, V>::is_ggc ()
+{
+ return is_same<V, va_gc>::value;
+}
+
+template <typename T>
+void
+gt_ggc_mx (fast_function_summary<T *, va_heap>* const &)
+{
+}
+
+template <typename T>
+void
+gt_pch_nx (fast_function_summary<T *, va_heap>* const &)
+{
+}
+
+template <typename T>
+void
+gt_pch_nx (fast_function_summary<T *, va_heap>* const&, gt_pointer_operator,
+ void *)
+{
+}
+
+template <typename T>
+void
+gt_ggc_mx (fast_function_summary<T *, va_gc>* const &summary)
+{
+ ggc_test_and_set_mark (summary->m_vector);
+ gt_ggc_mx (summary->m_vector);
+}
+
+template <typename T>
+void
+gt_pch_nx (fast_function_summary<T *, va_gc>* const &summary)
+{
+ gt_pch_nx (summary->m_vector);
+}
+
+template <typename T>
+void
+gt_pch_nx (fast_function_summary<T *, va_gc>* const& summary,
+ gt_pointer_operator op,
+ void *cookie)
+{
+ gt_pch_nx (summary->m_vector, op, cookie);
+}
+
+/* Base class for call_summary and fast_call_summary classes. */
+
+template <class T>
+class call_summary_base
+{
+public:
+ /* Default construction takes SYMTAB as an argument. */
+ call_summary_base (symbol_table *symtab): m_symtab (symtab),
+ m_initialize_when_cloning (true), m_released (false)
+ {}
+
/* Basic implementation of removal operation. */
virtual void remove (cgraph_edge *, T *) {}
/* Basic implementation of duplication operation. */
virtual void duplicate (cgraph_edge *, cgraph_edge *, T *, T *) {}
+protected:
/* Allocates new data that are stored within map. */
T* allocate_new ()
{
/* Call gcc_internal_because we do not want to call finalizer for
a type T. We call dtor explicitly. */
- return m_ggc ? new (ggc_internal_alloc (sizeof (T))) T () : new T () ;
+ return is_ggc () ? new (ggc_internal_alloc (sizeof (T))) T () : new T () ;
}
/* Release an item that is stored within map. */
- void release (T *item);
+ void release (T *item)
+ {
+ if (is_ggc ())
+ {
+ item->~T ();
+ ggc_free (item);
+ }
+ else
+ delete item;
+ }
+
+ /* Unregister all call-graph hooks. */
+ void unregister_hooks ();
+
+ /* Symbol table the summary is registered to. */
+ symbol_table *m_symtab;
+
+ /* Internal summary removal hook pointer. */
+ cgraph_edge_hook_list *m_symtab_removal_hook;
+ /* Internal summary duplication hook pointer. */
+ cgraph_2edge_hook_list *m_symtab_duplication_hook;
+ /* Initialize summary for an edge that is cloned. */
+ bool m_initialize_when_cloning;
+ /* Indicates if the summary is released. */
+ bool m_released;
+
+private:
+ /* Return true when the summary uses GGC memory for allocation. */
+ virtual bool is_ggc () = 0;
+};
+
+template <typename T>
+void
+call_summary_base<T>::unregister_hooks ()
+{
+ m_symtab->remove_edge_removal_hook (m_symtab_removal_hook);
+ m_symtab->remove_edge_duplication_hook (m_symtab_duplication_hook);
+}
+
+/* An impossible class templated by non-pointers so, which makes sure that only
+ summaries gathering pointers can be created. */
+
+template <class T>
+class call_summary
+{
+private:
+ call_summary ();
+};
+
+/* Class to store auxiliary information about call graph edges. */
+
+template <class T>
+class GTY((user)) call_summary <T *>: public call_summary_base<T>
+{
+public:
+ /* Default construction takes SYMTAB as an argument. */
+ call_summary (symbol_table *symtab, bool ggc = false)
+ : call_summary_base<T> (symtab), m_ggc (ggc), m_map (13, ggc)
+ {
+ this->m_symtab_removal_hook
+ = this->m_symtab->add_edge_removal_hook (call_summary::symtab_removal,
+ this);
+ this->m_symtab_duplication_hook
+ = this->m_symtab->add_edge_duplication_hook (call_summary::symtab_duplication,
+ this);
+ }
+
+ /* Destructor. */
+ virtual ~call_summary ()
+ {
+ release ();
+ }
+
+ /* Destruction method that can be called for GGC purpose. */
+ using call_summary_base<T>::release;
+ void release ();
+
+ /* Traverses all summarys with an edge E called with
+ ARG as argument. */
+ template<typename Arg, bool (*f)(const T &, Arg)>
+ void traverse (Arg a) const
+ {
+ m_map.traverse <f> (a);
+ }
/* Getter for summary callgraph edge pointer.
If a summary for an edge does not exist, it will be created. */
bool existed;
T **v = &m_map.get_or_insert (edge->get_uid (), &existed);
if (!existed)
- *v = allocate_new ();
+ *v = this->allocate_new ();
return *v;
}
}
/* Remove edge from summary. */
+ using call_summary_base<T>::remove;
void remove (cgraph_edge *edge)
{
int uid = edge->get_uid ();
if (v)
{
m_map.remove (uid);
- release (*v);
+ this->release (*v);
}
}
- /* Return number of elements handled by data structure. */
- size_t elements ()
- {
- return m_map.elements ();
- }
-
/* Return true if a summary for the given EDGE already exists. */
bool exists (cgraph_edge *edge)
{
/* Indication if we use ggc summary. */
bool m_ggc;
- /* Initialize summary for an edge that is cloned. */
- bool m_initialize_when_cloning;
-
private:
+ /* Indication if we use ggc summary. */
+ virtual bool is_ggc ()
+ {
+ return m_ggc;
+ }
+
typedef int_hash <int, 0, -1> map_hash;
/* Main summary store, where summary ID is used as key. */
hash_map <map_hash, T *> m_map;
- /* Internal summary removal hook pointer. */
- cgraph_edge_hook_list *m_symtab_removal_hook;
- /* Internal summary duplication hook pointer. */
- cgraph_2edge_hook_list *m_symtab_duplication_hook;
- /* Indicates if the summary is released. */
- bool m_released;
- /* Symbol table the summary is registered to. */
- symbol_table *m_symtab;
template <typename U> friend void gt_ggc_mx (call_summary <U *> * const &);
template <typename U> friend void gt_pch_nx (call_summary <U *> * const &);
void
call_summary<T *>::release ()
{
- if (m_released)
+ if (this->m_released)
return;
- m_symtab->remove_edge_removal_hook (m_symtab_removal_hook);
- m_symtab->remove_edge_duplication_hook (m_symtab_duplication_hook);
+ this->unregister_hooks ();
/* Release all summaries. */
typedef typename hash_map <map_hash, T *>::iterator map_iterator;
for (map_iterator it = m_map.begin (); it != m_map.end (); ++it)
- release ((*it).second);
+ this->release ((*it).second);
- m_released = true;
-}
-
-template <typename T>
-void
-call_summary<T *>::release (T *item)
-{
- if (m_ggc)
- {
- item->~T ();
- ggc_free (item);
- }
- else
- delete item;
+ this->m_released = true;
}
template <typename T>
call_summary<T *>::symtab_removal (cgraph_edge *edge, void *data)
{
call_summary *summary = (call_summary <T *> *) (data);
-
- int h_uid = edge->get_uid ();
- T **v = summary->m_map.get (h_uid);
-
- if (v)
- {
- summary->remove (edge, *v);
- summary->release (*v);
- summary->m_map.remove (h_uid);
- }
+ summary->remove (edge);
}
template <typename T>
if (summary->m_initialize_when_cloning)
edge1_summary = summary->get_create (edge1);
else
- {
- T **v = summary->m_map.get (edge1->get_uid ());
- if (v)
- {
- /* This load is necessary, because we insert a new value! */
- edge1_summary = *v;
- }
- }
+ edge1_summary = summary->get (edge1);
if (edge1_summary)
- {
- T *duplicate = summary->allocate_new ();
- summary->m_map.put (edge2->get_uid (), duplicate);
- summary->duplicate (edge1, edge2, edge1_summary, duplicate);
- }
+ summary->duplicate (edge1, edge2, edge1_summary,
+ summary->get_create (edge2));
}
template <typename T>
gt_pch_nx (&summary->m_map, op, cookie);
}
+/* We want to pass just pointer types as argument for fast_call_summary
+ template class. */
+
+template <class T, class V>
+class fast_call_summary
+{
+private:
+ fast_call_summary ();
+};
+
+/* Call vector summary is a fast implementation of call_summary that
+ utilizes vector as primary storage of summaries. */
+
+template <class T, class V>
+class GTY((user)) fast_call_summary <T *, V>: public call_summary_base<T>
+{
+public:
+ /* Default construction takes SYMTAB as an argument. */
+ fast_call_summary (symbol_table *symtab)
+ : call_summary_base<T> (symtab), m_vector (NULL)
+ {
+ vec_alloc (m_vector, 13);
+ this->m_symtab_removal_hook
+ = this->m_symtab->add_edge_removal_hook (fast_call_summary::symtab_removal,
+ this);
+ this->m_symtab_duplication_hook
+ = this->m_symtab->add_edge_duplication_hook (fast_call_summary::symtab_duplication,
+ this);
+ }
+
+ /* Destructor. */
+ virtual ~fast_call_summary ()
+ {
+ release ();
+ }
+
+ /* Destruction method that can be called for GGC purpose. */
+ using call_summary_base<T>::release;
+ void release ();
+
+ /* Traverses all summarys with an edge F called with
+ ARG as argument. */
+ template<typename Arg, bool (*f)(const T &, Arg)>
+ void traverse (Arg a) const
+ {
+ for (unsigned i = 0; i < m_vector->length (); i++)
+ if ((*m_vector[i]) != NULL)
+ f ((*m_vector)[i]);
+ }
+
+ /* Getter for summary callgraph edge pointer.
+ If a summary for an edge does not exist, it will be created. */
+ T* get_create (cgraph_edge *edge)
+ {
+ int id = edge->get_summary_id ();
+ if (id == -1)
+ id = this->m_symtab->assign_summary_id (edge);
+
+ if ((unsigned)id >= m_vector->length ())
+ vec_safe_grow_cleared (m_vector, this->m_symtab->edges_max_summary_id);
+
+ if ((*m_vector)[id] == NULL)
+ (*m_vector)[id] = this->allocate_new ();
+
+ return (*m_vector)[id];
+ }
+
+ /* Getter for summary callgraph edge pointer. */
+ T* get (cgraph_edge *edge) ATTRIBUTE_PURE
+ {
+ return exists (edge) ? (*m_vector)[edge->get_summary_id ()] : NULL;
+ }
+
+ /* Remove edge from summary. */
+ using call_summary_base<T>::remove;
+ void remove (cgraph_edge *edge)
+ {
+ if (exists (edge))
+ {
+ int id = edge->get_summary_id ();
+ this->release ((*m_vector)[id]);
+ (*m_vector)[id] = NULL;
+ }
+ }
+
+ /* Return true if a summary for the given EDGE already exists. */
+ bool exists (cgraph_edge *edge)
+ {
+ int id = edge->get_summary_id ();
+ return (id != -1
+ && (unsigned)id < m_vector->length ()
+ && (*m_vector)[id] != NULL);
+ }
+
+ /* Symbol removal hook that is registered to symbol table. */
+ static void symtab_removal (cgraph_edge *edge, void *data);
+
+ /* Symbol duplication hook that is registered to symbol table. */
+ static void symtab_duplication (cgraph_edge *edge1, cgraph_edge *edge2,
+ void *data);
+
+private:
+ virtual bool is_ggc ();
+
+ /* Summary is stored in the vector. */
+ vec <T *, V> *m_vector;
+
+ template <typename U> friend void gt_ggc_mx (fast_call_summary <U *, va_gc> * const &);
+ template <typename U> friend void gt_pch_nx (fast_call_summary <U *, va_gc> * const &);
+ template <typename U> friend void gt_pch_nx (fast_call_summary <U *, va_gc> * const &,
+ gt_pointer_operator, void *);
+};
+
+template <typename T, typename V>
+void
+fast_call_summary<T *, V>::release ()
+{
+ if (this->m_released)
+ return;
+
+ this->unregister_hooks ();
+
+ /* Release all summaries. */
+ for (unsigned i = 0; i < m_vector->length (); i++)
+ if ((*m_vector)[i] != NULL)
+ this->release ((*m_vector)[i]);
+
+ this->m_released = true;
+}
+
+template <typename T, typename V>
+void
+fast_call_summary<T *, V>::symtab_removal (cgraph_edge *edge, void *data)
+{
+ fast_call_summary *summary = (fast_call_summary <T *, V> *) (data);
+ summary->remove (edge);
+}
+
+template <typename T, typename V>
+void
+fast_call_summary<T *, V>::symtab_duplication (cgraph_edge *edge1,
+ cgraph_edge *edge2, void *data)
+{
+ fast_call_summary *summary = (fast_call_summary <T *, V> *) (data);
+ T *edge1_summary = NULL;
+
+ if (summary->m_initialize_when_cloning)
+ edge1_summary = summary->get_create (edge1);
+ else
+ edge1_summary = summary->get (edge1);
+
+ if (edge1_summary)
+ {
+ T *duplicate = summary->get_create (edge2);
+ summary->duplicate (edge1, edge2, edge1_summary, duplicate);
+ }
+}
+
+template <typename T, typename V>
+inline bool
+fast_call_summary<T *, V>::is_ggc ()
+{
+ return is_same<V, va_gc>::value;
+}
+
+template <typename T>
+void
+gt_ggc_mx (fast_call_summary<T *, va_heap>* const &summary)
+{
+}
+
+template <typename T>
+void
+gt_pch_nx (fast_call_summary<T *, va_heap>* const &summary)
+{
+}
+
+template <typename T>
+void
+gt_pch_nx (fast_call_summary<T *, va_heap>* const& summary,
+ gt_pointer_operator op,
+ void *cookie)
+{
+}
+
+template <typename T>
+void
+gt_ggc_mx (fast_call_summary<T *, va_gc>* const &summary)
+{
+ ggc_test_and_set_mark (summary->m_vector);
+ gt_ggc_mx (&summary->m_vector);
+}
+
+template <typename T>
+void
+gt_pch_nx (fast_call_summary<T *, va_gc>* const &summary)
+{
+ gt_pch_nx (&summary->m_vector);
+}
+
+template <typename T>
+void
+gt_pch_nx (fast_call_summary<T *, va_gc>* const& summary,
+ gt_pointer_operator op,
+ void *cookie)
+{
+ gt_pch_nx (&summary->m_vector, op, cookie);
+}
+
#endif /* GCC_SYMBOL_SUMMARY_H */
projects / thirdparty / gcc.git / commitdiff
