On 05/27/2015 03:56 PM, mliska wrote: > gcc/ChangeLog: > > 2015-04-30 Martin Liska > > * cselib.c (new_elt_list):Use new type-based pool allocator. > (new_elt_loc_list) Likewise. > (unchain_one_elt_list) Likewise. > (unchain_one_elt_loc_list) Likewise. > (unchain_one_value) Likewise. > (new_cselib_val) Likewise. > (cselib_init) Likewise. > (cselib_finish) Likewise. > --- > gcc/alias.c | 1 + > gcc/cfgcleanup.c | 1 + > gcc/cprop.c | 1 + > gcc/cselib.c | 63 ++++++++++++++++++++++++++++++++-------------------- > gcc/cselib.h | 33 ++++++++++++++++++++++++++- > gcc/gcse.c | 1 + > gcc/postreload.c | 1 + > gcc/print-rtl.c | 1 + > gcc/sel-sched-dump.c | 1 + > 9 files changed, 78 insertions(+), 25 deletions(-) > > diff --git a/gcc/alias.c b/gcc/alias.c > index aa7dc21..bc8e2b4 100644 > --- a/gcc/alias.c > +++ b/gcc/alias.c > @@ -53,6 +53,7 @@ along with GCC; see the file COPYING3. If not see > #include "tm_p.h" > #include "regs.h" > #include "diagnostic-core.h" > +#include "alloc-pool.h" > #include "cselib.h" > #include "hash-map.h" > #include "langhooks.h" > diff --git a/gcc/cfgcleanup.c b/gcc/cfgcleanup.c > index aff64ef..fc2ed31 100644 > --- a/gcc/cfgcleanup.c > +++ b/gcc/cfgcleanup.c > @@ -50,6 +50,7 @@ along with GCC; see the file COPYING3. If not see > #include "flags.h" > #include "recog.h" > #include "diagnostic-core.h" > +#include "alloc-pool.h" > #include "cselib.h" > #include "params.h" > #include "tm_p.h" > diff --git a/gcc/cprop.c b/gcc/cprop.c > index 57c44ef..41ca201 100644 > --- a/gcc/cprop.c > +++ b/gcc/cprop.c > @@ -63,6 +63,7 @@ along with GCC; see the file COPYING3. If not see > #include "expr.h" > #include "except.h" > #include "params.h" > +#include "alloc-pool.h" > #include "cselib.h" > #include "intl.h" > #include "obstack.h" > diff --git a/gcc/cselib.c b/gcc/cselib.c > index 7a50f50..8de85bc 100644 > --- a/gcc/cselib.c > +++ b/gcc/cselib.c > @@ -46,6 +46,7 @@ along with GCC; see the file COPYING3. If not see > #include "ggc.h" > #include "hash-table.h" > #include "dumpfile.h" > +#include "alloc-pool.h" > #include "cselib.h" > #include "predict.h" > #include "basic-block.h" > @@ -56,9 +57,25 @@ along with GCC; see the file COPYING3. If not see > #include "bitmap.h" > > /* A list of cselib_val structures. */ > -struct elt_list { > - struct elt_list *next; > - cselib_val *elt; > +struct elt_list > +{ > + struct elt_list *next; > + cselib_val *elt; > + > + /* Pool allocation new operator. */ > + inline void *operator new (size_t) > + { > + return pool.allocate (); > + } > + > + /* Delete operator utilizing pool allocation. */ > + inline void operator delete (void *ptr) > + { > + pool.remove((elt_list *) ptr); > + } > + > + /* Memory allocation pool. */ > + static pool_allocator pool; > }; > > static bool cselib_record_memory; > @@ -260,7 +277,13 @@ static unsigned int cfa_base_preserved_regno = INVALID_REGNUM; > May or may not contain the useless values - the list is compacted > each time memory is invalidated. */ > static cselib_val *first_containing_mem = &dummy_val; > -static alloc_pool elt_loc_list_pool, elt_list_pool, cselib_val_pool, value_pool; > + > +pool_allocator elt_list::pool ("elt_list", 10); > +pool_allocator elt_loc_list::pool ("elt_loc_list", 10); > +pool_allocator cselib_val::pool ("cselib_val_list", 10); > + > +static pool_allocator value_pool ("value", 100, RTX_CODE_SIZE (VALUE), > + true); > > /* If nonnull, cselib will call this function before freeing useless > VALUEs. A VALUE is deemed useless if its "locs" field is null. */ > @@ -288,8 +311,7 @@ void (*cselib_record_sets_hook) (rtx_insn *insn, struct cselib_set *sets, > static inline struct elt_list * > new_elt_list (struct elt_list *next, cselib_val *elt) > { > - struct elt_list *el; > - el = (struct elt_list *) pool_alloc (elt_list_pool); > + elt_list *el = new elt_list (); > el->next = next; > el->elt = elt; > return el; > @@ -373,14 +395,14 @@ new_elt_loc_list (cselib_val *val, rtx loc) > } > > /* Chain LOC back to VAL. */ > - el = (struct elt_loc_list *) pool_alloc (elt_loc_list_pool); > + el = new elt_loc_list; > el->loc = val->val_rtx; > el->setting_insn = cselib_current_insn; > el->next = NULL; > CSELIB_VAL_PTR (loc)->locs = el; > } > > - el = (struct elt_loc_list *) pool_alloc (elt_loc_list_pool); > + el = new elt_loc_list; > el->loc = loc; > el->setting_insn = cselib_current_insn; > el->next = next; > @@ -420,7 +442,7 @@ unchain_one_elt_list (struct elt_list **pl) > struct elt_list *l = *pl; > > *pl = l->next; > - pool_free (elt_list_pool, l); > + delete l; > } > > /* Likewise for elt_loc_lists. */ > @@ -431,7 +453,7 @@ unchain_one_elt_loc_list (struct elt_loc_list **pl) > struct elt_loc_list *l = *pl; > > *pl = l->next; > - pool_free (elt_loc_list_pool, l); > + delete l; > } > > /* Likewise for cselib_vals. This also frees the addr_list associated with > @@ -443,7 +465,7 @@ unchain_one_value (cselib_val *v) > while (v->addr_list) > unchain_one_elt_list (&v->addr_list); > > - pool_free (cselib_val_pool, v); > + delete v; > } > > /* Remove all entries from the hash table. Also used during > @@ -1306,7 +1328,7 @@ cselib_hash_rtx (rtx x, int create, machine_mode memmode) > static inline cselib_val * > new_cselib_val (unsigned int hash, machine_mode mode, rtx x) > { > - cselib_val *e = (cselib_val *) pool_alloc (cselib_val_pool); > + cselib_val *e = new cselib_val; > > gcc_assert (hash); > gcc_assert (next_uid); > @@ -1318,7 +1340,7 @@ new_cselib_val (unsigned int hash, machine_mode mode, rtx x) > precisely when we can have VALUE RTXen (when cselib is active) > so we don't need to put them in garbage collected memory. > ??? Why should a VALUE be an RTX in the first place? */ > - e->val_rtx = (rtx) pool_alloc (value_pool); > + e->val_rtx = value_pool.allocate (); > memset (e->val_rtx, 0, RTX_HDR_SIZE); > PUT_CODE (e->val_rtx, VALUE); > PUT_MODE (e->val_rtx, mode); > @@ -2729,13 +2751,6 @@ cselib_process_insn (rtx_insn *insn) > void > cselib_init (int record_what) > { > - elt_list_pool = create_alloc_pool ("elt_list", > - sizeof (struct elt_list), 10); > - elt_loc_list_pool = create_alloc_pool ("elt_loc_list", > - sizeof (struct elt_loc_list), 10); > - cselib_val_pool = create_alloc_pool ("cselib_val_list", > - sizeof (cselib_val), 10); > - value_pool = create_alloc_pool ("value", RTX_CODE_SIZE (VALUE), 100); > cselib_record_memory = record_what & CSELIB_RECORD_MEMORY; > cselib_preserve_constants = record_what & CSELIB_PRESERVE_CONSTANTS; > cselib_any_perm_equivs = false; > @@ -2777,10 +2792,10 @@ cselib_finish (void) > cselib_any_perm_equivs = false; > cfa_base_preserved_val = NULL; > cfa_base_preserved_regno = INVALID_REGNUM; > - free_alloc_pool (elt_list_pool); > - free_alloc_pool (elt_loc_list_pool); > - free_alloc_pool (cselib_val_pool); > - free_alloc_pool (value_pool); > + elt_list::pool.release (); > + elt_loc_list::pool.release (); > + cselib_val::pool.release (); > + value_pool.release (); > cselib_clear_table (); > delete cselib_hash_table; > cselib_hash_table = NULL; > diff --git a/gcc/cselib.h b/gcc/cselib.h > index 082bf54..5fe9076 100644 > --- a/gcc/cselib.h > +++ b/gcc/cselib.h > @@ -21,7 +21,8 @@ along with GCC; see the file COPYING3. If not see > #define GCC_CSELIB_H > > /* Describe a value. */ > -struct cselib_val { > +struct cselib_val > +{ > /* The hash value. */ > unsigned int hash; > > @@ -40,6 +41,21 @@ struct cselib_val { > struct elt_list *addr_list; > > struct cselib_val *next_containing_mem; > + > + /* Pool allocation new operator. */ > + inline void *operator new (size_t) > + { > + return pool.allocate (); > + } > + > + /* Delete operator utilizing pool allocation. */ > + inline void operator delete (void *ptr) > + { > + pool.remove((cselib_val *) ptr); > + } > + > + /* Memory allocation pool. */ > + static pool_allocator pool; > }; > > /* A list of rtl expressions that hold the same value. */ > @@ -50,6 +66,21 @@ struct elt_loc_list { > rtx loc; > /* The insn that made the equivalence. */ > rtx_insn *setting_insn; > + > + /* Pool allocation new operator. */ > + inline void *operator new (size_t) > + { > + return pool.allocate (); > + } > + > + /* Delete operator utilizing pool allocation. */ > + inline void operator delete (void *ptr) > + { > + pool.remove((elt_loc_list *) ptr); > + } > + > + /* Memory allocation pool. */ > + static pool_allocator pool; > }; > > /* Describe a single set that is part of an insn. */ > diff --git a/gcc/gcse.c b/gcc/gcse.c > index efbe4f4..28476fb 100644 > --- a/gcc/gcse.c > +++ b/gcc/gcse.c > @@ -180,6 +180,7 @@ along with GCC; see the file COPYING3. If not see > #include "except.h" > #include "ggc.h" > #include "params.h" > +#include "alloc-pool.h" > #include "cselib.h" > #include "intl.h" > #include "obstack.h" > diff --git a/gcc/postreload.c b/gcc/postreload.c > index 4d3c26f..06c4973 100644 > --- a/gcc/postreload.c > +++ b/gcc/postreload.c > @@ -63,6 +63,7 @@ along with GCC; see the file COPYING3. If not see > #include "basic-block.h" > #include "reload.h" > #include "recog.h" > +#include "alloc-pool.h" > #include "cselib.h" > #include "diagnostic-core.h" > #include "except.h" > diff --git a/gcc/print-rtl.c b/gcc/print-rtl.c > index 882f808..5e8838a 100644 > --- a/gcc/print-rtl.c > +++ b/gcc/print-rtl.c > @@ -52,6 +52,7 @@ along with GCC; see the file COPYING3. If not see > #include "basic-block.h" > #include "diagnostic.h" > #include "tree-pretty-print.h" > +#include "alloc-pool.h" > #include "cselib.h" > #include "dumpfile.h" /* for dump_flags */ > #include "dwarf2out.h" > diff --git a/gcc/sel-sched-dump.c b/gcc/sel-sched-dump.c > index 6f174a5..943fdd0 100644 > --- a/gcc/sel-sched-dump.c > +++ b/gcc/sel-sched-dump.c > @@ -40,6 +40,7 @@ along with GCC; see the file COPYING3. If not see > #include "insn-config.h" > #include "insn-attr.h" > #include "params.h" > +#include "alloc-pool.h" > #include "cselib.h" > #include "target.h" > > v2