From 1ef1d0ae0bf17f978e588b5326f2e23a093dd4cb Mon Sep 17 00:00:00 2001 From: Martin Liska Date: Mon, 1 Jun 2015 12:39:32 +0000 Subject: Change use to type-based pool allocator in cselib.c. * 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. git-svn-id: https://gcc.gnu.org/svn/gcc/trunk@223952 138bc75d-0d04-0410-961f-82ee72b054a4 --- gcc/ChangeLog | 11 +++++++++ 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 + 10 files changed, 89 insertions(+), 25 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index cf39571caa6..e3723ecdf90 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,14 @@ +2015-06-01 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. + 2015-06-01 Martin Liska * config/sh/sh.c (add_constant):Use new type-based pool allocator. diff --git a/gcc/alias.c b/gcc/alias.c index 68f71bf3030..ea539c5e580 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 aff64efcca9..fc2ed31d0bf 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 57c44ef58b1..41ca20124ed 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 7a50f5055bd..624d0a9724e 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 082bf5490f2..cdd06ad952a 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 efbe4f4cbb9..28476fb41a6 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 4d3c26fc7bf..06c49739ba7 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 882f808b1a2..5e8838ae4cd 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 6f174a5f850..943fdd00ba2 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" -- cgit v1.2.3