OpenE2K/gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

New symbol_summary class introduced.

Browse Source 
* 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.

From-SVN: r219004
This commit is contained in:
Martin Liska 2014-12-22 09:54:19 +01:00 committed by Martin Liska
parent fe55e976f1
commit 4008290f65
5 changed files with 301 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
gcc/ChangeLog
View File

@ -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

8
gcc/cgraph.h
View File

@ -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;
}

4
gcc/gengtype.c
View File

@ -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;

281
gcc/symbol-summary.h Normal file
View File

@ -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 */

3
gcc/toplev.c
View File

@ -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 ();