| /* Callgraph summary data structure. |
| Copyright (C) 2014-2021 Free Software Foundation, Inc. |
| Contributed by Martin Liska |
| |
| This file is part of GCC. |
| |
| GCC is free software; you can redistribute it and/or modify it under |
| the terms of the GNU General Public License as published by the Free |
| Software Foundation; either version 3, or (at your option) any later |
| version. |
| |
| GCC is distributed in the hope that it will be useful, but WITHOUT ANY |
| WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GCC; see the file COPYING3. If not see |
| <http://www.gnu.org/licenses/>. */ |
| |
| #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, |
| cgraph_node_hook symtab_insertion, |
| cgraph_node_hook symtab_removal, |
| cgraph_2node_hook symtab_duplication |
| CXX_MEM_STAT_INFO): |
| m_symtab (symtab), m_symtab_insertion (symtab_insertion), |
| m_symtab_removal (symtab_removal), |
| m_symtab_duplication (symtab_duplication), |
| m_symtab_insertion_hook (NULL), m_symtab_duplication_hook (NULL), |
| m_allocator ("function summary" PASS_MEM_STAT) |
| { |
| enable_insertion_hook (); |
| m_symtab_removal_hook |
| = m_symtab->add_cgraph_removal_hook (m_symtab_removal, this); |
| enable_duplication_hook (); |
| } |
| |
| /* Basic implementation of insert operation. */ |
| virtual void insert (cgraph_node *, T *) |
| { |
| /* In most cases, it makes no sense to create summaries without |
| initializing them. */ |
| gcc_unreachable (); |
| } |
| |
| /* 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 *) |
| { |
| /* It makes no sense to not copy anything during duplication. */ |
| gcc_unreachable (); |
| } |
| |
| /* Enable insertion hook invocation. */ |
| void enable_insertion_hook () |
| { |
| if (m_symtab_insertion_hook == NULL) |
| m_symtab_insertion_hook |
| = m_symtab->add_cgraph_insertion_hook (m_symtab_insertion, this); |
| } |
| |
| /* Enable insertion hook invocation. */ |
| void disable_insertion_hook () |
| { |
| if (m_symtab_insertion_hook != NULL) |
| { |
| m_symtab->remove_cgraph_insertion_hook (m_symtab_insertion_hook); |
| m_symtab_insertion_hook = NULL; |
| } |
| } |
| |
| /* Enable duplication hook invocation. */ |
| void enable_duplication_hook () |
| { |
| if (m_symtab_duplication_hook == NULL) |
| m_symtab_duplication_hook |
| = m_symtab->add_cgraph_duplication_hook (m_symtab_duplication, this); |
| } |
| |
| /* Enable duplication hook invocation. */ |
| void disable_duplication_hook () |
| { |
| if (m_symtab_duplication_hook != NULL) |
| { |
| m_symtab->remove_cgraph_duplication_hook (m_symtab_duplication_hook); |
| m_symtab_duplication_hook = NULL; |
| } |
| } |
| |
| 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 () |
| : m_allocator.allocate () ; |
| } |
| |
| /* Release an item that is stored within map. */ |
| void release (T *item) |
| { |
| if (is_ggc ()) |
| ggc_delete (item); |
| else |
| m_allocator.remove (item); |
| } |
| |
| /* Unregister all call-graph hooks. */ |
| void unregister_hooks (); |
| |
| /* Symbol table the summary is registered to. */ |
| symbol_table *m_symtab; |
| |
| /* Insertion function defined by a summary. */ |
| cgraph_node_hook m_symtab_insertion; |
| /* Removal function defined by a summary. */ |
| cgraph_node_hook m_symtab_removal; |
| /* Duplication function defined by a summary. */ |
| cgraph_2node_hook m_symtab_duplication; |
| |
| /* 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; |
| |
| private: |
| /* Return true when the summary uses GGC memory for allocation. */ |
| virtual bool is_ggc () = 0; |
| |
| /* Object allocator for heap allocation. */ |
| object_allocator<T> m_allocator; |
| }; |
| |
| template <typename T> |
| void |
| function_summary_base<T>::unregister_hooks () |
| { |
| disable_insertion_hook (); |
| m_symtab->remove_cgraph_removal_hook (m_symtab_removal_hook); |
| disable_duplication_hook (); |
| } |
| |
| /* We want to pass just pointer types as argument for function_summary |
| template class. */ |
| |
| template <class T> |
| class function_summary |
| { |
| private: |
| function_summary(); |
| }; |
| |
| /* Function summary is a helper class that is used to associate a data structure |
| related to a callgraph node. Typical usage can be seen in IPA passes which |
| create a temporary pass-related structures. The summary class registers |
| hooks that are triggered when a new node is inserted, duplicated and deleted. |
| A user of a summary class can ovewrite virtual methods than are triggered by |
| the summary if such hook is triggered. Apart from a callgraph node, the user |
| is given a data structure tied to the node. |
| |
| The function summary class can work both with a heap-allocated memory and |
| a memory gained by garbage collected memory. */ |
| |
| template <class T> |
| class GTY((user)) function_summary <T *>: public function_summary_base<T> |
| { |
| public: |
| /* Default construction takes SYMTAB as an argument. */ |
| function_summary (symbol_table *symtab, bool ggc = false CXX_MEM_STAT_INFO); |
| |
| /* Destructor. */ |
| virtual ~function_summary (); |
| |
| /* Traverses all summarys with a function F called with |
| ARG as argument. */ |
| template<typename Arg, bool (*f)(const T &, Arg)> |
| void traverse (Arg a) const |
| { |
| m_map.template traverse <f> (a); |
| } |
| |
| /* 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 = this->allocate_new (); |
| |
| return *v; |
| } |
| |
| /* Getter for summary callgraph node pointer. */ |
| T* get (cgraph_node *node) ATTRIBUTE_PURE |
| { |
| T **v = m_map.get (node->get_uid ()); |
| return v == NULL ? NULL : *v; |
| } |
| |
| /* Remove node from summary. */ |
| using function_summary_base<T>::remove; |
| void remove (cgraph_node *node) |
| { |
| int uid = node->get_uid (); |
| T **v = m_map.get (uid); |
| if (v) |
| { |
| m_map.remove (uid); |
| this->release (*v); |
| } |
| } |
| |
| /* Return true if a summary for the given NODE already exists. */ |
| bool exists (cgraph_node *node) |
| { |
| return m_map.get (node->get_uid ()) != 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); |
| |
| protected: |
| /* Indication if we use ggc summary. */ |
| 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; |
| |
| /* Main summary store, where summary ID is used as key. */ |
| hash_map <map_hash, T *> m_map; |
| |
| 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 U> friend void gt_pch_nx (function_summary <U *> * const &, |
| gt_pointer_operator, void *); |
| }; |
| |
| template <typename T> |
| function_summary<T *>::function_summary (symbol_table *symtab, bool ggc |
| MEM_STAT_DECL): |
| function_summary_base<T> (symtab, function_summary::symtab_insertion, |
| function_summary::symtab_removal, |
| function_summary::symtab_duplication |
| PASS_MEM_STAT), |
| m_ggc (ggc), m_map (13, ggc, true, GATHER_STATISTICS PASS_MEM_STAT) {} |
| |
| template <typename T> |
| function_summary<T *>::~function_summary () |
| { |
| 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) |
| this->release ((*it).second); |
| } |
| |
| template <typename T> |
| void |
| function_summary<T *>::symtab_insertion (cgraph_node *node, void *data) |
| { |
| gcc_checking_assert (node->get_uid ()); |
| function_summary *summary = (function_summary <T *> *) (data); |
| summary->insert (node, summary->get_create (node)); |
| } |
| |
| template <typename T> |
| void |
| function_summary<T *>::symtab_removal (cgraph_node *node, void *data) |
| { |
| gcc_checking_assert (node->get_uid ()); |
| function_summary *summary = (function_summary <T *> *) (data); |
| summary->remove (node); |
| } |
| |
| template <typename T> |
| void |
| function_summary<T *>::symtab_duplication (cgraph_node *node, |
| cgraph_node *node2, void *data) |
| { |
| function_summary *summary = (function_summary <T *> *) (data); |
| T *v = summary->get (node); |
| |
| if (v) |
| summary->duplicate (node, node2, v, summary->get_create (node2)); |
| } |
| |
| template <typename T> |
| void |
| gt_ggc_mx(function_summary<T *>* const &summary) |
| { |
| gcc_checking_assert (summary->m_ggc); |
| gt_ggc_mx (&summary->m_map); |
| } |
| |
| template <typename T> |
| void |
| gt_pch_nx (function_summary<T *> *const &) |
| { |
| gcc_unreachable (); |
| } |
| |
| template <typename T> |
| void |
| gt_pch_nx (function_summary<T *> *const &, gt_pointer_operator, void *) |
| { |
| gcc_unreachable (); |
| } |
| |
| /* Help template from std c++11. */ |
| |
| 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: |
| fast_function_summary (); |
| }; |
| |
| /* Function vector summary is a fast implementation of function_summary that |
| utilizes vector as primary storage of summaries. */ |
| |
| 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. */ |
| fast_function_summary (symbol_table *symtab CXX_MEM_STAT_INFO); |
| |
| /* Destructor. */ |
| virtual ~fast_function_summary (); |
| |
| /* Traverses all summarys with a function 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], a); |
| } |
| |
| /* 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 |
| MEM_STAT_DECL): |
| function_summary_base<T> (symtab, |
| fast_function_summary::symtab_insertion, |
| fast_function_summary::symtab_removal, |
| fast_function_summary::symtab_duplication |
| PASS_MEM_STAT), m_vector (NULL) |
| { |
| vec_alloc (m_vector, 13 PASS_MEM_STAT); |
| } |
| |
| template <typename T, typename V> |
| fast_function_summary<T *, V>::~fast_function_summary () |
| { |
| 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]); |
| vec_free (m_vector); |
| } |
| |
| 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); |
| 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 &) |
| { |
| gcc_unreachable (); |
| } |
| |
| template <typename T> |
| void |
| gt_pch_nx (fast_function_summary<T *, va_gc> *const &, gt_pointer_operator, |
| void *) |
| { |
| gcc_unreachable (); |
| } |
| |
| /* 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, cgraph_edge_hook symtab_removal, |
| cgraph_2edge_hook symtab_duplication CXX_MEM_STAT_INFO): |
| m_symtab (symtab), m_symtab_removal (symtab_removal), |
| m_symtab_duplication (symtab_duplication), m_symtab_duplication_hook (NULL), |
| m_initialize_when_cloning (false), |
| m_allocator ("call summary" PASS_MEM_STAT) |
| { |
| m_symtab_removal_hook |
| = m_symtab->add_edge_removal_hook (m_symtab_removal, this); |
| enable_duplication_hook (); |
| } |
| |
| /* 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 *) |
| { |
| gcc_unreachable (); |
| } |
| |
| /* Enable duplication hook invocation. */ |
| void enable_duplication_hook () |
| { |
| if (m_symtab_duplication_hook == NULL) |
| m_symtab_duplication_hook |
| = m_symtab->add_edge_duplication_hook (m_symtab_duplication, |
| this); |
| } |
| |
| /* Enable duplication hook invocation. */ |
| void disable_duplication_hook () |
| { |
| if (m_symtab_duplication_hook != NULL) |
| { |
| m_symtab->remove_edge_duplication_hook (m_symtab_duplication_hook); |
| m_symtab_duplication_hook = NULL; |
| } |
| } |
| |
| 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 () |
| : m_allocator.allocate (); |
| } |
| |
| /* Release an item that is stored within map. */ |
| void release (T *item) |
| { |
| if (is_ggc ()) |
| ggc_delete (item); |
| else |
| m_allocator.remove (item); |
| } |
| |
| /* Unregister all call-graph hooks. */ |
| void unregister_hooks (); |
| |
| /* Symbol table the summary is registered to. */ |
| symbol_table *m_symtab; |
| |
| /* Removal function defined by a summary. */ |
| cgraph_edge_hook m_symtab_removal; |
| /* Duplication function defined by a summary. */ |
| cgraph_2edge_hook m_symtab_duplication; |
| |
| /* 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; |
| |
| private: |
| /* Return true when the summary uses GGC memory for allocation. */ |
| virtual bool is_ggc () = 0; |
| |
| /* Object allocator for heap allocation. */ |
| object_allocator<T> m_allocator; |
| }; |
| |
| template <typename T> |
| void |
| call_summary_base<T>::unregister_hooks () |
| { |
| m_symtab->remove_edge_removal_hook (m_symtab_removal_hook); |
| disable_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 |
| CXX_MEM_STAT_INFO) |
| : call_summary_base<T> (symtab, call_summary::symtab_removal, |
| call_summary::symtab_duplication PASS_MEM_STAT), |
| m_ggc (ggc), m_map (13, ggc, true, GATHER_STATISTICS PASS_MEM_STAT) {} |
| |
| /* Destructor. */ |
| virtual ~call_summary (); |
| |
| /* 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.template traverse <f> (a); |
| } |
| |
| /* 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) |
| { |
| bool existed; |
| T **v = &m_map.get_or_insert (edge->get_uid (), &existed); |
| if (!existed) |
| *v = this->allocate_new (); |
| |
| return *v; |
| } |
| |
| /* Getter for summary callgraph edge pointer. */ |
| T* get (cgraph_edge *edge) ATTRIBUTE_PURE |
| { |
| T **v = m_map.get (edge->get_uid ()); |
| return v == NULL ? NULL : *v; |
| } |
| |
| /* Remove edge from summary. */ |
| using call_summary_base<T>::remove; |
| void remove (cgraph_edge *edge) |
| { |
| int uid = edge->get_uid (); |
| T **v = m_map.get (uid); |
| if (v) |
| { |
| m_map.remove (uid); |
| this->release (*v); |
| } |
| } |
| |
| /* Return true if a summary for the given EDGE already exists. */ |
| bool exists (cgraph_edge *edge) |
| { |
| return m_map.get (edge->get_uid ()) != 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); |
| |
| protected: |
| /* Indication if we use ggc summary. */ |
| 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; |
| |
| /* Main summary store, where summary ID is used as key. */ |
| hash_map <map_hash, T *> m_map; |
| |
| template <typename U> friend void gt_ggc_mx (call_summary <U *> * const &); |
| template <typename U> friend void gt_pch_nx (call_summary <U *> * const &); |
| template <typename U> friend void gt_pch_nx (call_summary <U *> * const &, |
| gt_pointer_operator, void *); |
| }; |
| |
| template <typename T> |
| call_summary<T *>::~call_summary () |
| { |
| 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) |
| this->release ((*it).second); |
| } |
| |
| template <typename T> |
| void |
| call_summary<T *>::symtab_removal (cgraph_edge *edge, void *data) |
| { |
| call_summary *summary = (call_summary <T *> *) (data); |
| summary->remove (edge); |
| } |
| |
| template <typename T> |
| void |
| call_summary<T *>::symtab_duplication (cgraph_edge *edge1, |
| cgraph_edge *edge2, void *data) |
| { |
| call_summary *summary = (call_summary <T *> *) (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) |
| summary->duplicate (edge1, edge2, edge1_summary, |
| summary->get_create (edge2)); |
| } |
| |
| template <typename T> |
| void |
| gt_ggc_mx(call_summary<T *>* const &summary) |
| { |
| gcc_checking_assert (summary->m_ggc); |
| gt_ggc_mx (&summary->m_map); |
| } |
| |
| template <typename T> |
| void |
| gt_pch_nx (call_summary<T *> *const &) |
| { |
| gcc_unreachable (); |
| } |
| |
| template <typename T> |
| void |
| gt_pch_nx (call_summary<T *> *const &, gt_pointer_operator, void *) |
| { |
| gcc_unreachable (); |
| } |
| |
| /* 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 CXX_MEM_STAT_INFO) |
| : call_summary_base<T> (symtab, fast_call_summary::symtab_removal, |
| fast_call_summary::symtab_duplication PASS_MEM_STAT), |
| m_vector (NULL) |
| { |
| vec_alloc (m_vector, 13 PASS_MEM_STAT); |
| } |
| |
| /* Destructor. */ |
| virtual ~fast_call_summary (); |
| |
| /* 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], a); |
| } |
| |
| /* 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> |
| fast_call_summary<T *, V>::~fast_call_summary () |
| { |
| 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]); |
| vec_free (m_vector); |
| } |
| |
| 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 ATTRIBUTE_UNUSED) |
| { |
| } |
| |
| template <typename T> |
| void |
| gt_pch_nx (fast_call_summary<T *, va_heap>* const &summary ATTRIBUTE_UNUSED) |
| { |
| } |
| |
| template <typename T> |
| void |
| gt_pch_nx (fast_call_summary<T *, va_heap>* const& summary ATTRIBUTE_UNUSED, |
| gt_pointer_operator op ATTRIBUTE_UNUSED, |
| void *cookie ATTRIBUTE_UNUSED) |
| { |
| } |
| |
| 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 &) |
| { |
| gcc_unreachable (); |
| } |
| |
| template <typename T> |
| void |
| gt_pch_nx (fast_call_summary<T *, va_gc> *const &, gt_pointer_operator, void *) |
| { |
| gcc_unreachable (); |
| } |
| |
| #endif /* GCC_SYMBOL_SUMMARY_H */ |