On Tue, Oct 14, 2014 at 04:05:25PM +0200, Richard Biener wrote:
> On Tue, Sep 2, 2014 at 3:56 AM, <tsaund...@mozilla.com> wrote:
> > From: Trevor Saunders <tsaund...@mozilla.com>
> >
> > Hi,
> >
> > There are still some issues to make this work really nicely, but this part
> > is
> > probably good enough its worth reviewing.
> >
> > For one thing you can't use ggc hash_map or set in front ends with some
> > types
> > or gengtype will decide to put the overloads of the marking routines it
> > provides in a front end file instead of the one it choose before breaking
> > other
> > front ends. However that seems to be an unrelated issue you can trigger it
> > without using hash_map/set, so we might as well solve it separetly.
> >
> > I had to have the entry marking functions for set deligate to the traits
> > class
> > because gcc < 4.9.1 issues clearly bogus errors if you inline the code from
> > the
> > traits implementation. We may well want to make map work the same way at
> > some
> > point to enable some of the special GTY attributes like if_marked, but it
> > doesn't seem to be necessary right now.
> >
> > bootstrapped + regtested without regressions on x86_64-unknown-linux-gnu,
> > ok?
>
> I have just noticed that this (ggc support for hash-table.h) makes it no
> longer
> suitable for use from generator programs (trying to merge from trunk on
> match-and-simplify). If you look at vec.h it has sophisticated guards
> to block out GGC support if GENERATOR_FILE is defined.
yeah, it works, but its kind of messy since some of the generator
programs include ggc.h.
> Can you try to fix this please?
I expect its doable, I can try to get it done later this week / week
end, but next few days are busy for me.
Trev
>
> Thanks,
> Richard.
>
> > Trev
> >
> > gcc/ChangeLog:
> >
> > 2014-09-01 Trevor Saunders <tsaund...@mozilla.com>
> >
> > * alloc-pool.c: Include coretypes.h.
> > * cgraph.h, dbxout.c, dwarf2out.c, except.c, except.h, function.c,
> > function.h, symtab.c, tree-cfg.c, tree-eh.c: Use hash_map and
> > hash_set instead of htab.
> > * ggc-page.c (in_gc): New variable.
> > (ggc_free): Do nothing if a collection is taking place.
> > (ggc_collect): Set in_gc appropriately.
> > * ggc.h (gt_ggc_mx(const char *)): New function.
> > (gt_pch_nx(const char *)): Likewise.
> > (gt_ggc_mx(int)): Likewise.
> > (gt_pch_nx(int)): Likewise.
> > * hash-map.h (hash_map::hash_entry::ggc_mx): Likewise.
> > (hash_map::hash_entry::pch_nx): Likewise.
> > (hash_map::hash_entry::pch_nx_helper): Likewise.
> > (hash_map::hash_map): Adjust.
> > (hash_map::create_ggc): New function.
> > (gt_ggc_mx): Likewise.
> > (gt_pch_nx): Likewise.
> > * hash-set.h (default_hashset_traits::ggc_mx): Likewise.
> > (default_hashset_traits::pch_nx): Likewise.
> > (hash_set::hash_entry::ggc_mx): Likewise.
> > (hash_set::hash_entry::pch_nx): Likewise.
> > (hash_set::hash_entry::pch_nx_helper): Likewise.
> > (hash_set::hash_set): Adjust.
> > (hash_set::create_ggc): New function.
> > (hash_set::elements): Likewise.
> > (gt_ggc_mx): Likewise.
> > (gt_pch_nx): Likewise.
> > * hash-table.h (hash_table::hash_table): Adjust.
> > (hash_table::m_ggc): New member.
> > (hash_table::~hash_table): Adjust.
> > (hash_table::expand): Likewise.
> > (hash_table::empty): Likewise.
> > (gt_ggc_mx): New function.
> > (hashtab_entry_note_pointers): Likewise.
> > (gt_pch_nx): Likewise.
> >
> >
> > diff --git a/gcc/alloc-pool.c b/gcc/alloc-pool.c
> > index 0d31835..bfaa0e4 100644
> > --- a/gcc/alloc-pool.c
> > +++ b/gcc/alloc-pool.c
> > @@ -20,6 +20,7 @@ along with GCC; see the file COPYING3. If not see
> >
> > #include "config.h"
> > #include "system.h"
> > +#include "coretypes.h"
> > #include "alloc-pool.h"
> > #include "hash-table.h"
> > #include "hash-map.h"
> > diff --git a/gcc/cgraph.h b/gcc/cgraph.h
> > index 879899c..030a1c7 100644
> > --- a/gcc/cgraph.h
> > +++ b/gcc/cgraph.h
> > @@ -1604,7 +1604,6 @@ struct cgraph_2node_hook_list;
> >
> > /* Map from a symbol to initialization/finalization priorities. */
> > struct GTY(()) symbol_priority_map {
> > - symtab_node *symbol;
> > priority_type init;
> > priority_type fini;
> > };
> > @@ -1872,7 +1871,7 @@ public:
> > htab_t GTY((param_is (symtab_node))) assembler_name_hash;
> >
> > /* Hash table used to hold init priorities. */
> > - htab_t GTY ((param_is (symbol_priority_map))) init_priority_hash;
> > + hash_map<symtab_node *, symbol_priority_map> *init_priority_hash;
> >
> > FILE* GTY ((skip)) dump_file;
> >
> > diff --git a/gcc/dbxout.c b/gcc/dbxout.c
> > index 946f1d1..d856bdd 100644
> > --- a/gcc/dbxout.c
> > +++ b/gcc/dbxout.c
> > @@ -2484,12 +2484,9 @@ dbxout_expand_expr (tree expr)
> > /* Helper function for output_used_types. Queue one entry from the
> > used types hash to be output. */
> >
> > -static int
> > -output_used_types_helper (void **slot, void *data)
> > +bool
> > +output_used_types_helper (tree const &type, vec<tree> *types_p)
> > {
> > - tree type = (tree) *slot;
> > - vec<tree> *types_p = (vec<tree> *) data;
> > -
> > if ((TREE_CODE (type) == RECORD_TYPE
> > || TREE_CODE (type) == UNION_TYPE
> > || TREE_CODE (type) == QUAL_UNION_TYPE
> > @@ -2502,7 +2499,7 @@ output_used_types_helper (void **slot, void *data)
> > && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
> > types_p->quick_push (TYPE_NAME (type));
> >
> > - return 1;
> > + return true;
> > }
> >
> > /* This is a qsort callback which sorts types and declarations into a
> > @@ -2544,8 +2541,9 @@ output_used_types (void)
> > int i;
> > tree type;
> >
> > - types.create (htab_elements (cfun->used_types_hash));
> > - htab_traverse (cfun->used_types_hash, output_used_types_helper,
> > &types);
> > + types.create (cfun->used_types_hash->elements ());
> > + cfun->used_types_hash->traverse<vec<tree> *,
> > output_used_types_helper>
> > + (&types);
> >
> > /* Sort by UID to prevent dependence on hash table ordering. */
> > types.qsort (output_types_sort);
> > diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c
> > index 7c0be86..21afc3f 100644
> > --- a/gcc/dwarf2out.c
> > +++ b/gcc/dwarf2out.c
> > @@ -18013,17 +18013,15 @@ dwarf2out_abstract_function (tree decl)
> > Marks the DIE of a given type in *SLOT as perennial, so it never gets
> > marked as unused by prune_unused_types. */
> >
> > -static int
> > -premark_used_types_helper (void **slot, void *data ATTRIBUTE_UNUSED)
> > +bool
> > +premark_used_types_helper (tree const &type, void *)
> > {
> > - tree type;
> > dw_die_ref die;
> >
> > - type = (tree) *slot;
> > die = lookup_type_die (type);
> > if (die != NULL)
> > die->die_perennial_p = 1;
> > - return 1;
> > + return true;
> > }
> >
> > /* Helper function of premark_types_used_by_global_vars which gets called
> > @@ -18066,7 +18064,7 @@ static void
> > premark_used_types (struct function *fun)
> > {
> > if (fun && fun->used_types_hash)
> > - htab_traverse (fun->used_types_hash, premark_used_types_helper, NULL);
> > + fun->used_types_hash->traverse<void *, premark_used_types_helper>
> > (NULL);
> > }
> >
> > /* Mark all members of types_used_by_vars_entry as perennial. */
> > diff --git a/gcc/except.c b/gcc/except.c
> > index 1f57c3f..fecc060 100644
> > --- a/gcc/except.c
> > +++ b/gcc/except.c
> > @@ -149,8 +149,13 @@ along with GCC; see the file COPYING3. If not see
> > #endif
> >
> > static GTY(()) int call_site_base;
> > -static GTY ((param_is (union tree_node)))
> > - htab_t type_to_runtime_map;
> > +
> > +struct tree_hash_traits : default_hashmap_traits
> > +{
> > + static hashval_t hash (tree t) { return TREE_HASH (t); }
> > +};
> > +
> > +static GTY (()) hash_map<tree, tree, tree_hash_traits>
> > *type_to_runtime_map;
> >
> > /* Describe the SjLj_Function_Context structure. */
> > static GTY(()) tree sjlj_fc_type_node;
> > @@ -213,9 +218,6 @@ typedef hash_table<action_record_hasher>
> > action_hash_type;
> > static bool get_eh_region_and_lp_from_rtx (const_rtx, eh_region *,
> > eh_landing_pad *);
> >
> > -static int t2r_eq (const void *, const void *);
> > -static hashval_t t2r_hash (const void *);
> > -
> > static void dw2_build_landing_pads (void);
> >
> > static int collect_one_action_chain (action_hash_type *, eh_region);
> > @@ -237,7 +239,8 @@ init_eh (void)
> > if (! flag_exceptions)
> > return;
> >
> > - type_to_runtime_map = htab_create_ggc (31, t2r_hash, t2r_eq, NULL);
> > + type_to_runtime_map
> > + = hash_map<tree, tree, tree_hash_traits>::create_ggc (31);
> >
> > /* Create the SjLj_Function_Context structure. This should match
> > the definition in unwind-sjlj.c. */
> > @@ -671,54 +674,28 @@ eh_region_outermost (struct function *ifun, eh_region
> > region_a,
> > return region_a;
> > }
> >
> > -static int
> > -t2r_eq (const void *pentry, const void *pdata)
> > -{
> > - const_tree const entry = (const_tree) pentry;
> > - const_tree const data = (const_tree) pdata;
> > -
> > - return TREE_PURPOSE (entry) == data;
> > -}
> > -
> > -static hashval_t
> > -t2r_hash (const void *pentry)
> > -{
> > - const_tree const entry = (const_tree) pentry;
> > - return TREE_HASH (TREE_PURPOSE (entry));
> > -}
> > -
> > void
> > add_type_for_runtime (tree type)
> > {
> > - tree *slot;
> > -
> > /* If TYPE is NOP_EXPR, it means that it already is a runtime type. */
> > if (TREE_CODE (type) == NOP_EXPR)
> > return;
> >
> > - slot = (tree *) htab_find_slot_with_hash (type_to_runtime_map, type,
> > - TREE_HASH (type), INSERT);
> > - if (*slot == NULL)
> > - {
> > - tree runtime = lang_hooks.eh_runtime_type (type);
> > - *slot = tree_cons (type, runtime, NULL_TREE);
> > - }
> > + bool existed = false;
> > + tree *slot = &type_to_runtime_map->get_or_insert (type, &existed);
> > + if (!existed)
> > + *slot = lang_hooks.eh_runtime_type (type);
> > }
> >
> > tree
> > lookup_type_for_runtime (tree type)
> > {
> > - tree *slot;
> > -
> > /* If TYPE is NOP_EXPR, it means that it already is a runtime type. */
> > if (TREE_CODE (type) == NOP_EXPR)
> > return type;
> >
> > - slot = (tree *) htab_find_slot_with_hash (type_to_runtime_map, type,
> > - TREE_HASH (type), NO_INSERT);
> > -
> > /* We should have always inserted the data earlier. */
> > - return TREE_VALUE (*slot);
> > + return *type_to_runtime_map->get (type);
> > }
> >
> >
> > @@ -3150,12 +3127,12 @@ output_function_exception_table (const char *fnname)
> > }
> >
> > void
> > -set_eh_throw_stmt_table (struct function *fun, struct htab *table)
> > +set_eh_throw_stmt_table (function *fun, hash_map<gimple, int> *table)
> > {
> > fun->eh->throw_stmt_table = table;
> > }
> >
> > -htab_t
> > +hash_map<gimple, int> *
> > get_eh_throw_stmt_table (struct function *fun)
> > {
> > return fun->eh->throw_stmt_table;
> > diff --git a/gcc/except.h b/gcc/except.h
> > index 71a8dce..3259151 100644
> > --- a/gcc/except.h
> > +++ b/gcc/except.h
> > @@ -204,7 +204,7 @@ struct GTY(()) eh_status
> >
> > /* At the gimple level, a mapping from gimple statement to landing pad
> > or must-not-throw region. See record_stmt_eh_region. */
> > - htab_t GTY((param_is (struct throw_stmt_node))) throw_stmt_table;
> > + hash_map<gimple, int> *GTY(()) throw_stmt_table;
> >
> > /* All of the runtime type data used by the function. These objects
> > are emitted to the lang-specific-data-area for the function. */
> > @@ -291,8 +291,8 @@ struct GTY(()) throw_stmt_node {
> > int lp_nr;
> > };
> >
> > -extern struct htab *get_eh_throw_stmt_table (struct function *);
> > -extern void set_eh_throw_stmt_table (struct function *, struct htab *);
> > +extern hash_map<gimple, int> *get_eh_throw_stmt_table (struct function *);
> > +extern void set_eh_throw_stmt_table (function *, hash_map<gimple, int> *);
> >
> > enum eh_personality_kind {
> > eh_personality_none,
> > diff --git a/gcc/function.c b/gcc/function.c
> > index 464c6cd..2e46799 100644
> > --- a/gcc/function.c
> > +++ b/gcc/function.c
> > @@ -6093,14 +6093,10 @@ used_types_insert_helper (tree type, struct
> > function *func)
> > {
> > if (type != NULL && func != NULL)
> > {
> > - void **slot;
> > -
> > if (func->used_types_hash == NULL)
> > - func->used_types_hash = htab_create_ggc (37, htab_hash_pointer,
> > - htab_eq_pointer, NULL);
> > - slot = htab_find_slot (func->used_types_hash, type, INSERT);
> > - if (*slot == NULL)
> > - *slot = type;
> > + func->used_types_hash = hash_set<tree>::create_ggc (37);
> > +
> > + func->used_types_hash->add (type);
> > }
> > }
> >
> > diff --git a/gcc/function.h b/gcc/function.h
> > index 071f5dd..e71210d 100644
> > --- a/gcc/function.h
> > +++ b/gcc/function.h
> > @@ -21,6 +21,7 @@ along with GCC; see the file COPYING3. If not see
> > #define GCC_FUNCTION_H
> >
> > #include "hashtab.h"
> > +#include "hash-set.h"
> > #include "vec.h"
> > #include "machmode.h"
> > #include "tm.h" /* For CUMULATIVE_ARGS. */
> > @@ -564,7 +565,7 @@ struct GTY(()) function {
> > struct language_function * language;
> >
> > /* Used types hash table. */
> > - htab_t GTY ((param_is (union tree_node))) used_types_hash;
> > + hash_set<tree> *GTY (()) used_types_hash;
> >
> > /* Dwarf2 Frame Description Entry, containing the Call Frame Instructions
> > used for unwinding. Only set when either dwarf2 unwinding or dwarf2
> > diff --git a/gcc/ggc-page.c b/gcc/ggc-page.c
> > index 3939540..2a9b2d9 100644
> > --- a/gcc/ggc-page.c
> > +++ b/gcc/ggc-page.c
> > @@ -500,6 +500,10 @@ static struct globals
> > } stats;
> > } G;
> >
> > +/* True if a gc is currently taking place. */
> > +
> > +static bool in_gc = false;
> > +
> > /* The size in bytes required to maintain a bitmap for the objects
> > on a page-entry. */
> > #define BITMAP_SIZE(Num_objects) \
> > @@ -1574,6 +1578,9 @@ ggc_get_size (const void *p)
> > void
> > ggc_free (void *p)
> > {
> > + if (in_gc)
> > + return;
> > +
> > page_entry *pe = lookup_page_table_entry (p);
> > size_t order = pe->order;
> > size_t size = OBJECT_SIZE (order);
> > @@ -2139,7 +2146,6 @@ ggc_collect (void)
> > MAX (G.allocated_last_gc, (size_t)PARAM_VALUE (GGC_MIN_HEAPSIZE) *
> > 1024);
> >
> > float min_expand = allocated_last_gc * PARAM_VALUE (GGC_MIN_EXPAND) /
> > 100;
> > -
> > if (G.allocated < allocated_last_gc + min_expand && !ggc_force_collect)
> > return;
> >
> > @@ -2162,6 +2168,7 @@ ggc_collect (void)
> >
> > invoke_plugin_callbacks (PLUGIN_GGC_START, NULL);
> >
> > + in_gc = true;
> > clear_marks ();
> > ggc_mark_roots ();
> > ggc_handle_finalizers ();
> > @@ -2173,6 +2180,7 @@ ggc_collect (void)
> > validate_free_objects ();
> > sweep_pages ();
> >
> > + in_gc = false;
> > G.allocated_last_gc = G.allocated;
> >
> > invoke_plugin_callbacks (PLUGIN_GGC_END, NULL);
> > diff --git a/gcc/ggc.h b/gcc/ggc.h
> > index 1c0fd3d..6280c43 100644
> > --- a/gcc/ggc.h
> > +++ b/gcc/ggc.h
> > @@ -337,4 +337,25 @@ ggc_alloc_cleared_gimple_statement_stat (size_t s
> > CXX_MEM_STAT_INFO)
> > ggc_internal_cleared_alloc (s PASS_MEM_STAT);
> > }
> >
> > +static inline void
> > +gt_ggc_mx (const char *s)
> > +{
> > + ggc_test_and_set_mark (const_cast<char *> (s));
> > +}
> > +
> > +static inline void
> > +gt_pch_nx (const char *)
> > +{
> > +}
> > +
> > +static inline void
> > +gt_ggc_mx (int)
> > +{
> > +}
> > +
> > +static inline void
> > +gt_pch_nx (int)
> > +{
> > +}
> > +
> > #endif
> > diff --git a/gcc/hash-map.h b/gcc/hash-map.h
> > index d2eed33..c65e1e5 100644
> > --- a/gcc/hash-map.h
> > +++ b/gcc/hash-map.h
> > @@ -21,6 +21,7 @@ along with GCC; see the file COPYING3. If not see
> > #ifndef hash_map_h
> > #define hash_map_h
> >
> > +#include <new>
> > #include "hash-table.h"
> >
> > /* implement default behavior for traits when types allow it. */
> > @@ -103,7 +104,7 @@ private:
> >
> > template<typename Key, typename Value,
> > typename Traits = default_hashmap_traits>
> > -class hash_map
> > +class GTY((user)) hash_map
> > {
> > struct hash_entry
> > {
> > @@ -135,10 +136,56 @@ class hash_map
> >
> > static void mark_empty (hash_entry &e) { Traits::mark_empty (e); }
> > static bool is_empty (const hash_entry &e) { return Traits::is_empty
> > (e); }
> > +
> > + static void ggc_mx (hash_entry &e)
> > + {
> > + gt_ggc_mx (e.m_key);
> > + gt_ggc_mx (e.m_value);
> > + }
> > +
> > + static void pch_nx (hash_entry &e)
> > + {
> > + gt_pch_nx (e.m_key);
> > + gt_pch_nx (e.m_value);
> > + }
> > +
> > + static void pch_nx (hash_entry &e, gt_pointer_operator op, void *c)
> > + {
> > + pch_nx_helper (e.m_key, op, c);
> > + pch_nx_helper (e.m_value, op, c);
> > + }
> > +
> > + private:
> > + template<typename T>
> > + static void
> > + pch_nx_helper (T &x, gt_pointer_operator op, void *cookie)
> > + {
> > + gt_pch_nx (&x, op, cookie);
> > + }
> > +
> > + static void
> > + pch_nx_helper (int, gt_pointer_operator, void *)
> > + {
> > + }
> > +
> > + template<typename T>
> > + static void
> > + pch_nx_helper (T *&x, gt_pointer_operator op, void *cookie)
> > + {
> > + op (&x, cookie);
> > + }
> > };
> >
> > public:
> > - explicit hash_map (size_t n = 13) : m_table (n) {}
> > + explicit hash_map (size_t n = 13, bool ggc = false) : m_table (n, ggc) {}
> > +
> > + /* Create a hash_map in ggc memory. */
> > + static hash_map *create_ggc (size_t size)
> > + {
> > + hash_map *map = ggc_alloc<hash_map> ();
> > + new (map) hash_map (size, true);
> > + return map;
> > + }
> >
> > /* If key k isn't already in the map add key k with value v to the map,
> > and
> > return false. Otherwise set the value of the entry for key k to be v
> > and
> > @@ -208,7 +255,35 @@ public:
> > }
> >
> > private:
> > +
> > + template<typename T, typename U, typename V> friend void gt_ggc_mx
> > (hash_map<T, U, V> *);
> > + template<typename T, typename U, typename V> friend void gt_pch_nx
> > (hash_map<T, U, V> *);
> > + template<typename T, typename U, typename V> friend void gt_pch_nx
> > (hash_map<T, U, V> *, gt_pointer_operator, void *);
> > +
> > hash_table<hash_entry> m_table;
> > };
> >
> > +/* ggc marking routines. */
> > +
> > +template<typename K, typename V, typename H>
> > +static inline void
> > +gt_ggc_mx (hash_map<K, V, H> *h)
> > +{
> > + gt_ggc_mx (&h->m_table);
> > +}
> > +
> > +template<typename K, typename V, typename H>
> > +static inline void
> > +gt_pch_nx (hash_map<K, V, H> *h)
> > +{
> > + gt_pch_nx (&h->m_table);
> > +}
> > +
> > +template<typename K, typename V, typename H>
> > +static inline void
> > +gt_pch_nx (hash_map<K, V, H> *h, gt_pointer_operator op, void *cookie)
> > +{
> > + op (&h->m_table.m_entries, cookie);
> > +}
> > +
> > #endif
> > diff --git a/gcc/hash-set.h b/gcc/hash-set.h
> > index 47bae9e..0a500cb 100644
> > --- a/gcc/hash-set.h
> > +++ b/gcc/hash-set.h
> > @@ -81,6 +81,26 @@ struct default_hashset_traits
> > /* Return true if the passed in entry is marked as empty. */
> >
> > template<typename T> static bool is_empty (T *e) { return e == NULL; }
> > +
> > + /* ggc walking routine, mark all objects refered to by this one. */
> > +
> > + template<typename T>
> > + static void
> > + ggc_mx (T &x)
> > + {
> > + extern void gt_ggc_mx (T &);
> > + gt_ggc_mx (x);
> > + }
> > +
> > + /* pch walking routine, note all objects refered to by this element. */
> > +
> > + template<typename T>
> > + static void
> > + pch_nx (T &x)
> > + {
> > + extern void gt_pch_nx (T &);
> > + gt_pch_nx (x);
> > + }
> > };
> >
> > template<typename Key, typename Traits = default_hashset_traits>
> > @@ -128,10 +148,50 @@ class hash_set
> > {
> > return Traits::is_empty (e.m_key);
> > }
> > +
> > + static void ggc_mx (hash_entry &e)
> > + {
> > + Traits::ggc_mx (e.m_key);
> > + }
> > +
> > + static void pch_nx (hash_entry &e)
> > + {
> > + Traits::pch_nx (e.m_key);
> > + }
> > +
> > + static void pch_nx (hash_entry &e, gt_pointer_operator op, void *c)
> > + {
> > + pch_nx_helper (e.m_key, op, c);
> > + }
> > +
> > + private:
> > + template<typename T>
> > + static void
> > + pch_nx_helper (T &x, gt_pointer_operator op, void *cookie)
> > + {
> > + gt_pch_nx (&x, op, cookie);
> > + }
> > +
> > + template<typename T>
> > + static void
> > + pch_nx_helper (T *&x, gt_pointer_operator op, void *cookie)
> > + {
> > + op (&x, cookie);
> > + }
> > };
> >
> > public:
> > - explicit hash_set (size_t n = 13) : m_table (n) {}
> > + explicit hash_set (size_t n = 13, bool ggc = false) : m_table (n, ggc) {}
> > +
> > + /* Create a hash_set in gc memory with space for at least n elements. */
> > +
> > + static hash_set *
> > + create_ggc (size_t n)
> > + {
> > + hash_set *set = ggc_alloc<hash_set> ();
> > + new (set) hash_set (n, true);
> > + return set;
> > + }
> >
> > /* If key k isn't already in the map add it to the map, and
> > return false. Otherwise return true. */
> > @@ -166,8 +226,40 @@ public:
> > f ((*iter).m_key, a);
> > }
> >
> > + /* Return the number of elements in the set. */
> > +
> > + size_t elements () const { return m_table.elements (); }
> > +
> > private:
> > +
> > + template<typename T, typename U> friend void gt_ggc_mx (hash_set<T, U>
> > *);
> > + template<typename T, typename U> friend void gt_pch_nx (hash_set<T, U>
> > *);
> > + template<typename T, typename U> friend void gt_pch_nx (hash_set<T,
> > U> *, gt_pointer_operator, void *);
> > +
> > hash_table<hash_entry> m_table;
> > };
> >
> > +/* ggc marking routines. */
> > +
> > +template<typename K, typename H>
> > +static inline void
> > +gt_ggc_mx (hash_set<K, H> *h)
> > +{
> > + gt_ggc_mx (&h->m_table);
> > +}
> > +
> > +template<typename K, typename H>
> > +static inline void
> > +gt_pch_nx (hash_set<K, H> *h)
> > +{
> > + gt_pch_nx (&h->m_table);
> > +}
> > +
> > +template<typename K, typename H>
> > +static inline void
> > +gt_pch_nx (hash_set<K, H> *h, gt_pointer_operator op, void *cookie)
> > +{
> > + op (&h->m_table.m_entries, cookie);
> > +}
> > +
> > #endif
> > diff --git a/gcc/hash-table.h b/gcc/hash-table.h
> > index 9c6a34a..4c18786 100644
> > --- a/gcc/hash-table.h
> > +++ b/gcc/hash-table.h
> > @@ -196,8 +196,11 @@ along with GCC; see the file COPYING3. If not see
> > #ifndef TYPED_HASHTAB_H
> > #define TYPED_HASHTAB_H
> >
> > +#include "ggc.h"
> > #include "hashtab.h"
> >
> > +template<typename, typename, typename> class hash_map;
> > +template<typename, typename> class hash_set;
> >
> > /* The ordinary memory allocator. */
> > /* FIXME (crowl): This allocator may be extracted for wider sharing later.
> > */
> > @@ -998,7 +1001,7 @@ class hash_table<Descriptor, Allocator, true>
> > typedef typename Descriptor::compare_type compare_type;
> >
> > public:
> > - hash_table (size_t);
> > + explicit hash_table (size_t, bool ggc = false);
> > ~hash_table ();
> >
> > /* Current size (in entries) of the hash table. */
> > @@ -1105,6 +1108,11 @@ public:
> > }
> >
> > private:
> > + template<typename T> friend void gt_ggc_mx (hash_table<T> *);
> > + template<typename T> friend void gt_pch_nx (hash_table<T> *);
> > + template<typename T> friend void hashtab_entry_note_pointers (void *,
> > void *, gt_pointer_operator, void *);
> > + template<typename T, typename U, typename V> friend void gt_pch_nx
> > (hash_map<T, U, V> *, gt_pointer_operator, void *);
> > + template<typename T, typename U> friend void gt_pch_nx (hash_set<T, U>
> > *, gt_pointer_operator, void *);
> >
> > value_type *find_empty_slot_for_expand (hashval_t);
> > void expand ();
> > @@ -1149,18 +1157,26 @@ private:
> > /* Current size (in entries) of the hash table, as an index into the
> > table of primes. */
> > unsigned int m_size_prime_index;
> > +
> > + /* if m_entries is stored in ggc memory. */
> > + bool m_ggc;
> > };
> >
> > template<typename Descriptor, template<typename Type> class Allocator>
> > -hash_table<Descriptor, Allocator, true>::hash_table (size_t size) :
> > - m_n_elements (0), m_n_deleted (0), m_searches (0), m_collisions (0)
> > +hash_table<Descriptor, Allocator, true>::hash_table (size_t size, bool
> > ggc) :
> > + m_n_elements (0), m_n_deleted (0), m_searches (0), m_collisions (0),
> > + m_ggc (ggc)
> > {
> > unsigned int size_prime_index;
> >
> > size_prime_index = hash_table_higher_prime_index (size);
> > size = prime_tab[size_prime_index].prime;
> >
> > - m_entries = Allocator <value_type> ::data_alloc (size);
> > + if (!m_ggc)
> > + m_entries = Allocator <value_type> ::data_alloc (size);
> > + else
> > + m_entries = ggc_cleared_vec_alloc<value_type> (size);
> > +
> > gcc_assert (m_entries != NULL);
> > m_size = size;
> > m_size_prime_index = size_prime_index;
> > @@ -1173,7 +1189,10 @@ hash_table<Descriptor, Allocator, true>::~hash_table
> > ()
> > if (!is_empty (m_entries[i]) && !is_deleted (m_entries[i]))
> > Descriptor::remove (m_entries[i]);
> >
> > - Allocator <value_type> ::data_free (m_entries);
> > + if (!m_ggc)
> > + Allocator <value_type> ::data_free (m_entries);
> > + else
> > + ggc_free (m_entries);
> > }
> >
> > /* Similar to find_slot, but without several unwanted side effects:
> > @@ -1245,7 +1264,12 @@ hash_table<Descriptor, Allocator, true>::expand ()
> > nsize = osize;
> > }
> >
> > - value_type *nentries = Allocator <value_type> ::data_alloc (nsize);
> > + value_type *nentries;
> > + if (!m_ggc)
> > + nentries = Allocator <value_type> ::data_alloc (nsize);
> > + else
> > + nentries = ggc_cleared_vec_alloc<value_type> (nsize);
> > +
> > gcc_assert (nentries != NULL);
> > m_entries = nentries;
> > m_size = nsize;
> > @@ -1269,7 +1293,10 @@ hash_table<Descriptor, Allocator, true>::expand ()
> > }
> > while (p < olimit);
> >
> > - Allocator <value_type> ::data_free (oentries);
> > + if (!m_ggc)
> > + Allocator <value_type> ::data_free (oentries);
> > + else
> > + ggc_free (oentries);
> > }
> >
> > template<typename Descriptor, template<typename Type> class Allocator>
> > @@ -1290,8 +1317,17 @@ hash_table<Descriptor, Allocator, true>::empty ()
> > int nindex = hash_table_higher_prime_index (1024 / sizeof (PTR));
> > int nsize = prime_tab[nindex].prime;
> >
> > - Allocator <value_type> ::data_free (m_entries);
> > - m_entries = Allocator <value_type> ::data_alloc (nsize);
> > + if (!m_ggc)
> > + {
> > + Allocator <value_type> ::data_free (m_entries);
> > + m_entries = Allocator <value_type> ::data_alloc (nsize);
> > + }
> > + else
> > + {
> > + ggc_free (m_entries);
> > + m_entries = ggc_cleared_vec_alloc<value_type> (nsize);
> > + }
> > +
> > m_size = nsize;
> > m_size_prime_index = nindex;
> > }
> > @@ -1519,4 +1555,59 @@ hash_table<Descriptor, Allocator,
> > true>::iterator::operator ++ ()
> > (ITER) != (HTAB).end () ? (RESULT = *(ITER) , true) : false; \
> > ++(ITER))
> >
> > +/* ggc walking routines. */
> > +
> > +template<typename E>
> > +static inline void
> > +gt_ggc_mx (hash_table<E> *h)
> > +{
> > + typedef hash_table<E> table;
> > +
> > + if (!ggc_test_and_set_mark (h->m_entries))
> > + return;
> > +
> > + for (size_t i = 0; i < h->m_size; i++)
> > + {
> > + if (table::is_empty (h->m_entries[i])
> > + || table::is_deleted (h->m_entries[i]))
> > + continue;
> > +
> > + E::ggc_mx (h->m_entries[i]);
> > + }
> > +}
> > +
> > +template<typename D>
> > +static inline void
> > +hashtab_entry_note_pointers (void *obj, void *h, gt_pointer_operator op,
> > + void *cookie)
> > +{
> > + hash_table<D> *map = static_cast<hash_table<D> *> (h);
> > + gcc_assert (map->m_entries == obj);
> > + for (size_t i = 0; i < map->m_size; i++)
> > + {
> > + typedef hash_table<D> table;
> > + if (table::is_empty (map->m_entries[i])
> > + || table::is_deleted (map->m_entries[i]))
> > + continue;
> > +
> > + D::pch_nx (map->m_entries[i], op, cookie);
> > + }
> > +}
> > +
> > +template<typename D>
> > +static void
> > +gt_pch_nx (hash_table<D> *h)
> > +{
> > + gcc_assert (gt_pch_note_object (h->m_entries, h,
> > + hashtab_entry_note_pointers<D>));
> > + for (size_t i = 0; i < h->m_size; i++)
> > + {
> > + if (hash_table<D>::is_empty (h->m_entries[i])
> > + || hash_table<D>::is_deleted (h->m_entries[i]))
> > + continue;
> > +
> > + D::pch_nx (h->m_entries[i]);
> > + }
> > +}
> > +
> > #endif /* TYPED_HASHTAB_H */
> > diff --git a/gcc/symtab.c b/gcc/symtab.c
> > index 739a8e4..792b3b5 100644
> > --- a/gcc/symtab.c
> > +++ b/gcc/symtab.c
> > @@ -407,15 +407,7 @@ symtab_node::unregister (void)
> > if (!is_a <varpool_node *> (this) || !DECL_HARD_REGISTER (decl))
> > symtab->unlink_from_assembler_name_hash (this, false);
> > if (in_init_priority_hash)
> > - {
> > - symbol_priority_map in;
> > - void **slot;
> > - in.symbol = this;
> > -
> > - slot = htab_find_slot (symtab->init_priority_hash, &in, NO_INSERT);
> > - if (slot)
> > - htab_clear_slot (symtab->init_priority_hash, slot);
> > - }
> > + symtab->init_priority_hash->remove (this);
> > }
> >
> >
> > @@ -1455,14 +1447,10 @@ symtab_node::set_section (const char *section)
> > priority_type
> > symtab_node::get_init_priority ()
> > {
> > - symbol_priority_map *h;
> > - symbol_priority_map in;
> > -
> > if (!this->in_init_priority_hash)
> > return DEFAULT_INIT_PRIORITY;
> > - in.symbol = this;
> > - h = (symbol_priority_map *) htab_find (symtab->init_priority_hash,
> > - &in);
> > +
> > + symbol_priority_map *h = symtab->init_priority_hash->get (this);
> > return h ? h->init : DEFAULT_INIT_PRIORITY;
> > }
> >
> > @@ -1481,35 +1469,12 @@ enum availability symtab_node::get_availability
> > (void)
> > priority_type
> > cgraph_node::get_fini_priority ()
> > {
> > - symbol_priority_map *h;
> > - symbol_priority_map in;
> > -
> > if (!this->in_init_priority_hash)
> > return DEFAULT_INIT_PRIORITY;
> > - in.symbol = this;
> > - h = (symbol_priority_map *) htab_find (symtab->init_priority_hash,
> > - &in);
> > + symbol_priority_map *h = symtab->init_priority_hash->get (this);
> > return h ? h->fini : DEFAULT_INIT_PRIORITY;
> > }
> >
> > -/* Return true if the from tree in both priority maps are equal. */
> > -
> > -int
> > -symbol_priority_map_eq (const void *va, const void *vb)
> > -{
> > - const symbol_priority_map *const a = (const symbol_priority_map *) va,
> > - *const b = (const symbol_priority_map *) vb;
> > - return (a->symbol == b->symbol);
> > -}
> > -
> > -/* Hash a from symbol in a symbol_priority_map. */
> > -
> > -unsigned int
> > -symbol_priority_map_hash (const void *item)
> > -{
> > - return htab_hash_pointer (((const symbol_priority_map *)item)->symbol);
> > -}
> > -
> > /* Return the initialization and finalization priority information for
> > DECL. If there is no previous priority information, a freshly
> > allocated structure is returned. */
> > @@ -1517,23 +1482,14 @@ symbol_priority_map_hash (const void *item)
> > symbol_priority_map *
> > symtab_node::priority_info (void)
> > {
> > - symbol_priority_map in;
> > - symbol_priority_map *h;
> > - void **loc;
> > -
> > - in.symbol = this;
> > if (!symtab->init_priority_hash)
> > - symtab->init_priority_hash = htab_create_ggc (512,
> > - symbol_priority_map_hash,
> > - symbol_priority_map_eq,
> > 0);
> > + symtab->init_priority_hash = hash_map<symtab_node *,
> > symbol_priority_map>::create_ggc (13);
> >
> > - loc = htab_find_slot (symtab->init_priority_hash, &in, INSERT);
> > - h = (symbol_priority_map *) *loc;
> > - if (!h)
> > + bool existed;
> > + symbol_priority_map *h
> > + = &symtab->init_priority_hash->get_or_insert (this, &existed);
> > + if (!existed)
> > {
> > - h = ggc_cleared_alloc<symbol_priority_map> ();
> > - *loc = h;
> > - h->symbol = this;
> > h->init = DEFAULT_INIT_PRIORITY;
> > h->fini = DEFAULT_INIT_PRIORITY;
> > in_init_priority_hash = true;
> > diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c
> > index c75516d..e89d76a 100644
> > --- a/gcc/tree-cfg.c
> > +++ b/gcc/tree-cfg.c
> > @@ -4723,19 +4723,17 @@ verify_node_sharing (tree *tp, int *walk_subtrees,
> > void *data)
> > }
> >
> > static bool eh_error_found;
> > -static int
> > -verify_eh_throw_stmt_node (void **slot, void *data)
> > +bool
> > +verify_eh_throw_stmt_node (const gimple &stmt, const int &,
> > + hash_set<gimple> *visited)
> > {
> > - struct throw_stmt_node *node = (struct throw_stmt_node *)*slot;
> > - hash_set<void *> *visited = (hash_set<void *> *) data;
> > -
> > - if (!visited->contains (node->stmt))
> > + if (!visited->contains (stmt))
> > {
> > error ("dead STMT in EH table");
> > - debug_gimple_stmt (node->stmt);
> > + debug_gimple_stmt (stmt);
> > eh_error_found = true;
> > }
> > - return 1;
> > + return true;
> > }
> >
> > /* Verify if the location LOCs block is in BLOCKS. */
> > @@ -4996,10 +4994,10 @@ verify_gimple_in_cfg (struct function *fn, bool
> > verify_nothrow)
> > }
> >
> > eh_error_found = false;
> > - if (get_eh_throw_stmt_table (cfun))
> > - htab_traverse (get_eh_throw_stmt_table (cfun),
> > - verify_eh_throw_stmt_node,
> > - &visited_stmts);
> > + hash_map<gimple, int> *eh_table = get_eh_throw_stmt_table (cfun);
> > + if (eh_table)
> > + eh_table->traverse<hash_set<gimple> *, verify_eh_throw_stmt_node>
> > + (&visited_stmts);
> >
> > if (err || eh_error_found)
> > internal_error ("verify_gimple failed");
> > diff --git a/gcc/tree-eh.c b/gcc/tree-eh.c
> > index 6c6faf3..9da8da2 100644
> > --- a/gcc/tree-eh.c
> > +++ b/gcc/tree-eh.c
> > @@ -77,23 +77,12 @@ typedef union {tree *tp; tree t; gimple g;} treemple;
> > static void
> > add_stmt_to_eh_lp_fn (struct function *ifun, gimple t, int num)
> > {
> > - struct throw_stmt_node *n;
> > - void **slot;
> > -
> > gcc_assert (num != 0);
> >
> > - n = ggc_alloc<throw_stmt_node> ();
> > - n->stmt = t;
> > - n->lp_nr = num;
> > -
> > if (!get_eh_throw_stmt_table (ifun))
> > - set_eh_throw_stmt_table (ifun, htab_create_ggc (31, struct_ptr_hash,
> > - struct_ptr_eq,
> > - ggc_free));
> > + set_eh_throw_stmt_table (ifun, hash_map<gimple, int>::create_ggc (31));
> >
> > - slot = htab_find_slot (get_eh_throw_stmt_table (ifun), n, INSERT);
> > - gcc_assert (!*slot);
> > - *slot = n;
> > + gcc_assert (!get_eh_throw_stmt_table (ifun)->put (t, num));
> > }
> >
> > /* Add statement T in the current function (cfun) to EH landing pad NUM.
> > */
> > @@ -130,22 +119,14 @@ record_stmt_eh_region (eh_region region, gimple t)
> > bool
> > remove_stmt_from_eh_lp_fn (struct function *ifun, gimple t)
> > {
> > - struct throw_stmt_node dummy;
> > - void **slot;
> > -
> > if (!get_eh_throw_stmt_table (ifun))
> > return false;
> >
> > - dummy.stmt = t;
> > - slot = htab_find_slot (get_eh_throw_stmt_table (ifun), &dummy,
> > - NO_INSERT);
> > - if (slot)
> > - {
> > - htab_clear_slot (get_eh_throw_stmt_table (ifun), slot);
> > - return true;
> > - }
> > - else
> > + if (!get_eh_throw_stmt_table (ifun)->get (t))
> > return false;
> > +
> > + get_eh_throw_stmt_table (ifun)->remove (t);
> > + return true;
> > }
> >
> >
> > @@ -166,14 +147,11 @@ remove_stmt_from_eh_lp (gimple t)
> > int
> > lookup_stmt_eh_lp_fn (struct function *ifun, gimple t)
> > {
> > - struct throw_stmt_node *p, n;
> > -
> > if (ifun->eh->throw_stmt_table == NULL)
> > return 0;
> >
> > - n.stmt = t;
> > - p = (struct throw_stmt_node *) htab_find (ifun->eh->throw_stmt_table,
> > &n);
> > - return p ? p->lp_nr : 0;
> > + int *lp_nr = ifun->eh->throw_stmt_table->get (t);
> > + return lp_nr ? *lp_nr : 0;
> > }
> >
> > /* Likewise, but always use the current function. */
> > --
> > 2.1.0
> >
