diff options
| -rw-r--r-- | gcc/ChangeLog | 8 | ||||
| -rw-r--r-- | gcc/cgraph.h | 8 | ||||
| -rw-r--r-- | gcc/gengtype.c | 4 | ||||
| -rw-r--r-- | gcc/symbol-summary.h | 281 | ||||
| -rw-r--r-- | gcc/toplev.c | 3 |
5 files changed, 301 insertions, 3 deletions
diff --git a/gcc/ChangeLog b/gcc/ChangeLog index e5d16f9d01e..d5e2b7b8899 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,11 @@ +2014-12-22 Martin Liska <mliska@suse.cz> + + * cgraph.h (symbol_table::allocate_cgraph_symbol): Summary UID + is filled up. + * symbol-summary.h: New file. + * gengtype.c (open_base_files): Add symbol-summary.h. + * toplev.c (general_init): Call constructor of symbol_table. + 2014-12-17 Oleg Endo <olegendo@gcc.gnu.org> PR target/55212 diff --git a/gcc/cgraph.h b/gcc/cgraph.h index fbb9922f147..0cff779a0d8 100644 --- a/gcc/cgraph.h +++ b/gcc/cgraph.h @@ -1255,6 +1255,8 @@ public: int count_materialization_scale; /* Unique id of the node. */ int uid; + /* Summary unique id of the node. */ + int summary_uid; /* ID assigned by the profiling. */ unsigned int profile_id; /* Time profiler: first run of function. */ @@ -1837,6 +1839,10 @@ public: friend class cgraph_node; friend class cgraph_edge; + symbol_table (): cgraph_max_summary_uid (1) + { + } + /* Initialize callgraph dump file. */ void initialize (void); @@ -2033,6 +2039,7 @@ public: int cgraph_count; int cgraph_max_uid; + int cgraph_max_summary_uid; int edges_count; int edges_max_uid; @@ -2361,6 +2368,7 @@ symbol_table::allocate_cgraph_symbol (void) node->uid = cgraph_max_uid++; } + node->summary_uid = cgraph_max_summary_uid++; return node; } diff --git a/gcc/gengtype.c b/gcc/gengtype.c index 04b77471bd2..3f9ad0b3463 100644 --- a/gcc/gengtype.c +++ b/gcc/gengtype.c @@ -1740,8 +1740,8 @@ open_base_files (void) "tree-ssa-loop-niter.h", "tree-into-ssa.h", "tree-dfa.h", "tree-ssa.h", "reload.h", "cpp-id-data.h", "tree-chrec.h", "except.h", "output.h", "cfgloop.h", "target.h", "lto-streamer.h", - "target-globals.h", "ipa-ref.h", "cgraph.h", "ipa-prop.h", - "ipa-inline.h", "dwarf2out.h", "omp-low.h", NULL + "target-globals.h", "ipa-ref.h", "cgraph.h", "symbol-summary.h", + "ipa-prop.h", "ipa-inline.h", "dwarf2out.h", "omp-low.h", NULL }; const char *const *ifp; outf_p gtype_desc_c; diff --git a/gcc/symbol-summary.h b/gcc/symbol-summary.h new file mode 100644 index 00000000000..d001f640b10 --- /dev/null +++ b/gcc/symbol-summary.h @@ -0,0 +1,281 @@ +/* Callgraph summary data structure. + Copyright (C) 2014 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 + +/* We want to pass just pointer types as argument for function_summary + template class. */ + +template <class T> +class function_summary +{ +private: + function_summary(); +}; + +template <class T> +class GTY((user)) function_summary <T *> +{ +public: + /* Default construction takes SYMTAB as an argument. */ + function_summary (symbol_table *symtab, bool ggc = false): m_ggc (ggc), + m_map (13, ggc), m_insertion_enabled (true), m_symtab (symtab) + { +#ifdef ENABLE_CHECKING + cgraph_node *node; + + FOR_EACH_FUNCTION (node) + { + gcc_checking_assert (node->summary_uid > 0); + } +#endif + + 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); + } + + /* Destructor. */ + virtual ~function_summary () + { + release (); + } + + /* Destruction method that can be called for GGT purpose. */ + void release () + { + if (m_symtab_insertion_hook) + m_symtab->remove_cgraph_insertion_hook (m_symtab_insertion_hook); + + if (m_symtab_removal_hook) + m_symtab->remove_cgraph_removal_hook (m_symtab_removal_hook); + + if (m_symtab_duplication_hook) + m_symtab->remove_cgraph_duplication_hook (m_symtab_duplication_hook); + + m_symtab_insertion_hook = NULL; + m_symtab_removal_hook = NULL; + m_symtab_duplication_hook = NULL; + } + + /* 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.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 () + { + return m_ggc ? new (ggc_alloc <T> ()) T() : new T () ; + } + + /* Getter for summary callgraph node pointer. */ + T* get (cgraph_node *node) + { + return get (node->summary_uid); + } + + /* Return number of elements handled by data structure. */ + size_t elements () + { + return m_map.elements (); + } + + /* 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) + { + function_summary *summary = (function_summary <T *> *) (data); + + if (summary->m_insertion_enabled) + summary->insert (node, summary->get (node)); + } + + /* Symbol removal hook that is registered to symbol table. */ + static void symtab_removal (cgraph_node *node, void *data) + { + gcc_checking_assert (node->summary_uid); + function_summary *summary = (function_summary <T *> *) (data); + + int summary_uid = node->summary_uid; + T **v = summary->m_map.get (summary_uid); + + if (v) + { + summary->remove (node, *v); + + if (!summary->m_ggc) + delete (*v); + + summary->m_map.remove (summary_uid); + } + } + + /* Symbol duplication hook that is registered to symbol table. */ + static void symtab_duplication (cgraph_node *node, cgraph_node *node2, + void *data) + { + function_summary *summary = (function_summary <T *> *) (data); + T **v = summary->m_map.get (node->summary_uid); + + gcc_checking_assert (node2->summary_uid > 0); + + if (v) + { + /* This load is necessary, because we insert a new value! */ + T *data = *v; + T *duplicate = summary->allocate_new (); + summary->m_map.put (node2->summary_uid, duplicate); + summary->duplicate (node, node2, data, duplicate); + } + } + +protected: + /* Indication if we use ggc summary. */ + bool m_ggc; + +private: + struct summary_hashmap_traits: default_hashmap_traits + { + static const int deleted_value = -1; + static const int empty_value = 0; + + static hashval_t + hash (const int v) + { + return (hashval_t)v; + } + + template<typename Type> + static bool + is_deleted (Type &e) + { + return e.m_key == deleted_value; + } + + template<typename Type> + static bool + is_empty (Type &e) + { + return e.m_key == empty_value; + } + + template<typename Type> + static void + mark_deleted (Type &e) + { + e.m_key = deleted_value; + } + + template<typename Type> + static void + mark_empty (Type &e) + { + e.m_key = empty_value; + } + }; + + /* Getter for summary callgraph ID. */ + T* get (int uid) + { + bool existed; + T **v = &m_map.get_or_insert (uid, &existed); + if (!existed) + *v = allocate_new (); + + return *v; + } + + /* Main summary store, where summary ID is used as key. */ + hash_map <int, T *, summary_hashmap_traits> 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; + /* Indicates if insertion hook is enabled. */ + bool m_insertion_enabled; + /* 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 U> friend void gt_pch_nx (function_summary <U *> * const &, + gt_pointer_operator, void *); +}; + +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 &summary) +{ + gcc_checking_assert (summary->m_ggc); + gt_pch_nx (&summary->m_map); +} + +template <typename T> +void +gt_pch_nx(function_summary<T *>* const& summary, gt_pointer_operator op, + void *cookie) +{ + gcc_checking_assert (summary->m_ggc); + gt_pch_nx (&summary->m_map, op, cookie); +} + +#endif /* GCC_SYMBOL_SUMMARY_H */ diff --git a/gcc/toplev.c b/gcc/toplev.c index 04f63df4983..7e06247f052 100644 --- a/gcc/toplev.c +++ b/gcc/toplev.c @@ -92,6 +92,7 @@ along with GCC; see the file COPYING3. If not see #include "dwarf2out.h" #include "bitmap.h" #include "ipa-reference.h" +#include "symbol-summary.h" #include "ipa-prop.h" #include "gcse.h" #include "insn-codes.h" @@ -1212,7 +1213,7 @@ general_init (const char *argv0) /* Create the singleton holder for global state. Doing so also creates the pass manager and with it the passes. */ g = new gcc::context (); - symtab = ggc_cleared_alloc <symbol_table> (); + symtab = new (ggc_cleared_alloc <symbol_table> ()) symbol_table (); statistics_early_init (); finish_params (); |