This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
Re: [PATCH 1/2] convert the rest of the users of pointer_map to hash_map
- From: Richard Biener <richard dot guenther at gmail dot com>
- To: tsaunders at mozilla dot com
- Cc: GCC Patches <gcc-patches at gcc dot gnu dot org>
- Date: Wed, 6 Aug 2014 10:41:42 +0200
- Subject: Re: [PATCH 1/2] convert the rest of the users of pointer_map to hash_map
- Authentication-results: sourceware.org; auth=none
- References: <1407288483-3351-1-git-send-email-tsaunders at mozilla dot com>
On Wed, Aug 6, 2014 at 3:28 AM, <tsaunders@mozilla.com> wrote:
> From: Trevor Saunders <tsaunders@mozilla.com>
>
> hi,
>
> just what it says on the tin.
>
> bootstrapped + regtested on x86_64-unknown-linux-gnu, also bootstrapped on
> i686-unknown-linux-gnu, ran config-list.mk, ok? gcc/
Ok.
Time to remove pointer_map?
Thanks,
Richard.
> Trev
>
> * hash-map.h (default_hashmap_traits): Adjust overloads of hash
> function to not conflict.
> * alias.c, cfgexpand.c, dse.c, except.h, gimple-expr.c,
> gimple-ssa-strength-reduction.c, gimple-ssa.h, ifcvt.c,
> lto-streamer-out.c, lto-streamer.h, tree-affine.c, tree-affine.h,
> tree-predcom.c, tree-scalar-evolution.c, tree-ssa-loop-im.c,
> tree-ssa-loop-niter.c, tree-ssa.c, value-prof.c: Use hash_map instead
> of pointer_map.
>
> gcc/cp/
>
> * cp-tree.h, pt.c: Use hash_map instead of pointer_map.
>
> gcc/lto/
>
> * lto-partition.c, lto.c: Use hash_map instead of pointer_map.
> ---
> gcc/alias.c | 5 +--
> gcc/cfgexpand.c | 89 +++++++++++++++++++++----------------
> gcc/cp/cp-tree.h | 3 +-
> gcc/cp/pt.c | 23 ++++------
> gcc/dse.c | 5 +--
> gcc/except.h | 1 -
> gcc/gimple-expr.c | 5 +--
> gcc/gimple-ssa-strength-reduction.c | 2 +-
> gcc/gimple-ssa.h | 3 +-
> gcc/hash-map.h | 7 +--
> gcc/ifcvt.c | 53 ++++++++++------------
> gcc/lto-streamer-out.c | 7 +--
> gcc/lto-streamer.h | 2 +-
> gcc/lto/lto-partition.c | 17 +++----
> gcc/lto/lto.c | 15 +++----
> gcc/tree-affine.c | 28 +++++-------
> gcc/tree-affine.h | 9 ++--
> gcc/tree-predcom.c | 2 +-
> gcc/tree-scalar-evolution.c | 2 +-
> gcc/tree-ssa-loop-im.c | 4 +-
> gcc/tree-ssa-loop-niter.c | 36 ++++++---------
> gcc/tree-ssa.c | 2 +-
> gcc/value-prof.c | 42 ++++++++++-------
> 23 files changed, 174 insertions(+), 188 deletions(-)
>
> diff --git a/gcc/alias.c b/gcc/alias.c
> index 0246dd7..d8e10db 100644
> --- a/gcc/alias.c
> +++ b/gcc/alias.c
> @@ -302,10 +302,9 @@ ao_ref_from_mem (ao_ref *ref, const_rtx mem)
> && ! is_global_var (base)
> && cfun->gimple_df->decls_to_pointers != NULL)
> {
> - void *namep;
> - namep = pointer_map_contains (cfun->gimple_df->decls_to_pointers, base);
> + tree *namep = cfun->gimple_df->decls_to_pointers->get (base);
> if (namep)
> - ref->base = build_simple_mem_ref (*(tree *)namep);
> + ref->base = build_simple_mem_ref (*namep);
> }
>
> ref->ref_alias_set = MEM_ALIAS_SET (mem);
> diff --git a/gcc/cfgexpand.c b/gcc/cfgexpand.c
> index b20be10..5ac22a2 100644
> --- a/gcc/cfgexpand.c
> +++ b/gcc/cfgexpand.c
> @@ -216,7 +216,7 @@ struct stack_var
> static struct stack_var *stack_vars;
> static size_t stack_vars_alloc;
> static size_t stack_vars_num;
> -static struct pointer_map_t *decl_to_stack_part;
> +static hash_map<tree, size_t> *decl_to_stack_part;
>
> /* Conflict bitmaps go on this obstack. This allows us to destroy
> all of them in one big sweep. */
> @@ -300,10 +300,10 @@ add_stack_var (tree decl)
> = XRESIZEVEC (struct stack_var, stack_vars, stack_vars_alloc);
> }
> if (!decl_to_stack_part)
> - decl_to_stack_part = pointer_map_create ();
> + decl_to_stack_part = new hash_map<tree, size_t>;
>
> v = &stack_vars[stack_vars_num];
> - * (size_t *)pointer_map_insert (decl_to_stack_part, decl) = stack_vars_num;
> + decl_to_stack_part->put (decl, stack_vars_num);
>
> v->decl = decl;
> v->size = tree_to_uhwi (DECL_SIZE_UNIT (SSAVAR (decl)));
> @@ -375,7 +375,7 @@ visit_op (gimple, tree op, tree, void *data)
> && DECL_P (op)
> && DECL_RTL_IF_SET (op) == pc_rtx)
> {
> - size_t *v = (size_t *) pointer_map_contains (decl_to_stack_part, op);
> + size_t *v = decl_to_stack_part->get (op);
> if (v)
> bitmap_set_bit (active, *v);
> }
> @@ -395,8 +395,7 @@ visit_conflict (gimple, tree op, tree, void *data)
> && DECL_P (op)
> && DECL_RTL_IF_SET (op) == pc_rtx)
> {
> - size_t *v =
> - (size_t *) pointer_map_contains (decl_to_stack_part, op);
> + size_t *v = decl_to_stack_part->get (op);
> if (v && bitmap_set_bit (active, *v))
> {
> size_t num = *v;
> @@ -447,8 +446,7 @@ add_scope_conflicts_1 (basic_block bb, bitmap work, bool for_conflict)
> if (TREE_CODE (lhs) != VAR_DECL)
> continue;
> if (DECL_RTL_IF_SET (lhs) == pc_rtx
> - && (v = (size_t *)
> - pointer_map_contains (decl_to_stack_part, lhs)))
> + && (v = decl_to_stack_part->get (lhs)))
> bitmap_clear_bit (work, *v);
> }
> else if (!is_gimple_debug (stmt))
> @@ -587,6 +585,26 @@ stack_var_cmp (const void *a, const void *b)
> return 0;
> }
>
> +struct part_traits : default_hashmap_traits
> +{
> + template<typename T>
> + static bool
> + is_deleted (T &e)
> + { return e.m_value == reinterpret_cast<void *> (1); }
> +
> + template<typename T> static bool is_empty (T &e) { return e.m_value == NULL; }
> + template<typename T>
> + static void
> + mark_deleted (T &e)
> + { e.m_value = reinterpret_cast<T> (1); }
> +
> + template<typename T>
> + static void
> + mark_empty (T &e)
> + { e.m_value = NULL; }
> +};
> +
> +typedef hash_map<size_t, bitmap, part_traits> part_hashmap;
>
> /* If the points-to solution *PI points to variables that are in a partition
> together with other variables add all partition members to the pointed-to
> @@ -594,7 +612,7 @@ stack_var_cmp (const void *a, const void *b)
>
> static void
> add_partitioned_vars_to_ptset (struct pt_solution *pt,
> - struct pointer_map_t *decls_to_partitions,
> + part_hashmap *decls_to_partitions,
> hash_set<bitmap> *visited, bitmap temp)
> {
> bitmap_iterator bi;
> @@ -616,8 +634,7 @@ add_partitioned_vars_to_ptset (struct pt_solution *pt,
> EXECUTE_IF_SET_IN_BITMAP (pt->vars, 0, i, bi)
> if ((!temp
> || !bitmap_bit_p (temp, i))
> - && (part = (bitmap *) pointer_map_contains (decls_to_partitions,
> - (void *)(size_t) i)))
> + && (part = decls_to_partitions->get (i)))
> bitmap_ior_into (temp, *part);
> if (!bitmap_empty_p (temp))
> bitmap_ior_into (pt->vars, temp);
> @@ -631,7 +648,7 @@ add_partitioned_vars_to_ptset (struct pt_solution *pt,
> static void
> update_alias_info_with_stack_vars (void)
> {
> - struct pointer_map_t *decls_to_partitions = NULL;
> + part_hashmap *decls_to_partitions = NULL;
> size_t i, j;
> tree var = NULL_TREE;
>
> @@ -648,8 +665,8 @@ update_alias_info_with_stack_vars (void)
>
> if (!decls_to_partitions)
> {
> - decls_to_partitions = pointer_map_create ();
> - cfun->gimple_df->decls_to_pointers = pointer_map_create ();
> + decls_to_partitions = new part_hashmap;
> + cfun->gimple_df->decls_to_pointers = new hash_map<tree, tree>;
> }
>
> /* Create an SSA_NAME that points to the partition for use
> @@ -667,10 +684,8 @@ update_alias_info_with_stack_vars (void)
> tree decl = stack_vars[j].decl;
> unsigned int uid = DECL_PT_UID (decl);
> bitmap_set_bit (part, uid);
> - *((bitmap *) pointer_map_insert (decls_to_partitions,
> - (void *)(size_t) uid)) = part;
> - *((tree *) pointer_map_insert (cfun->gimple_df->decls_to_pointers,
> - decl)) = name;
> + decls_to_partitions->put (uid, part);
> + cfun->gimple_df->decls_to_pointers->put (decl, name);
> if (TREE_ADDRESSABLE (decl))
> TREE_ADDRESSABLE (name) = 1;
> }
> @@ -703,7 +718,7 @@ update_alias_info_with_stack_vars (void)
> add_partitioned_vars_to_ptset (&cfun->gimple_df->escaped,
> decls_to_partitions, &visited, temp);
>
> - pointer_map_destroy (decls_to_partitions);
> + delete decls_to_partitions;
> BITMAP_FREE (temp);
> }
> }
> @@ -1530,7 +1545,7 @@ init_vars_expansion (void)
> bitmap_obstack_initialize (&stack_var_bitmap_obstack);
>
> /* A map from decl to stack partition. */
> - decl_to_stack_part = pointer_map_create ();
> + decl_to_stack_part = new hash_map<tree, size_t>;
>
> /* Initialize local stack smashing state. */
> has_protected_decls = false;
> @@ -1549,7 +1564,7 @@ fini_vars_expansion (void)
> stack_vars = NULL;
> stack_vars_sorted = NULL;
> stack_vars_alloc = stack_vars_num = 0;
> - pointer_map_destroy (decl_to_stack_part);
> + delete decl_to_stack_part;
> decl_to_stack_part = NULL;
> }
>
> @@ -1666,7 +1681,6 @@ expand_used_vars (void)
> tree var, outer_block = DECL_INITIAL (current_function_decl);
> vec<tree> maybe_local_decls = vNULL;
> rtx var_end_seq = NULL_RTX;
> - struct pointer_map_t *ssa_name_decls;
> unsigned i;
> unsigned len;
> bool gen_stack_protect_signal = false;
> @@ -1686,7 +1700,7 @@ expand_used_vars (void)
>
> init_vars_expansion ();
>
> - ssa_name_decls = pointer_map_create ();
> + hash_map<tree, tree> ssa_name_decls;
> for (i = 0; i < SA.map->num_partitions; i++)
> {
> tree var = partition_to_var (SA.map, i);
> @@ -1697,10 +1711,10 @@ expand_used_vars (void)
> we could have coalesced (those with the same type). */
> if (SSA_NAME_VAR (var) == NULL_TREE)
> {
> - void **slot = pointer_map_insert (ssa_name_decls, TREE_TYPE (var));
> + tree *slot = &ssa_name_decls.get_or_insert (TREE_TYPE (var));
> if (!*slot)
> - *slot = (void *) create_tmp_reg (TREE_TYPE (var), NULL);
> - replace_ssa_name_symbol (var, (tree) *slot);
> + *slot = create_tmp_reg (TREE_TYPE (var), NULL);
> + replace_ssa_name_symbol (var, *slot);
> }
>
> /* Always allocate space for partitions based on VAR_DECLs. But for
> @@ -1727,7 +1741,6 @@ expand_used_vars (void)
> }
> }
> }
> - pointer_map_destroy (ssa_name_decls);
>
> if (flag_stack_protect == SPCT_FLAG_STRONG)
> gen_stack_protect_signal
> @@ -1957,7 +1970,7 @@ maybe_dump_rtl_for_gimple_stmt (gimple stmt, rtx since)
>
> /* Maps the blocks that do not contain tree labels to rtx labels. */
>
> -static struct pointer_map_t *lab_rtx_for_bb;
> +static hash_map<basic_block, rtx> *lab_rtx_for_bb;
>
> /* Returns the label_rtx expression for a label starting basic block BB. */
>
> @@ -1967,14 +1980,13 @@ label_rtx_for_bb (basic_block bb ATTRIBUTE_UNUSED)
> gimple_stmt_iterator gsi;
> tree lab;
> gimple lab_stmt;
> - void **elt;
>
> if (bb->flags & BB_RTL)
> return block_label (bb);
>
> - elt = pointer_map_contains (lab_rtx_for_bb, bb);
> + rtx *elt = lab_rtx_for_bb->get (bb);
> if (elt)
> - return (rtx) *elt;
> + return *elt;
>
> /* Find the tree label if it is present. */
>
> @@ -1991,9 +2003,9 @@ label_rtx_for_bb (basic_block bb ATTRIBUTE_UNUSED)
> return label_rtx (lab);
> }
>
> - elt = pointer_map_insert (lab_rtx_for_bb, bb);
> - *elt = gen_label_rtx ();
> - return (rtx) *elt;
> + rtx l = gen_label_rtx ();
> + lab_rtx_for_bb->put (bb, l);
> + return l;
> }
>
>
> @@ -4878,7 +4890,6 @@ expand_gimple_basic_block (basic_block bb, bool disable_tail_calls)
> rtx note, last;
> edge e;
> edge_iterator ei;
> - void **elt;
>
> if (dump_file)
> fprintf (dump_file, "\n;; Generating RTL for gimple basic block %d\n",
> @@ -4922,7 +4933,7 @@ expand_gimple_basic_block (basic_block bb, bool disable_tail_calls)
> stmt = NULL;
> }
>
> - elt = pointer_map_contains (lab_rtx_for_bb, bb);
> + rtx *elt = lab_rtx_for_bb->get (bb);
>
> if (stmt || elt)
> {
> @@ -4935,7 +4946,7 @@ expand_gimple_basic_block (basic_block bb, bool disable_tail_calls)
> }
>
> if (elt)
> - emit_label ((rtx) *elt);
> + emit_label (*elt);
>
> /* Java emits line number notes in the top of labels.
> ??? Make this go away once line number notes are obsoleted. */
> @@ -5792,7 +5803,7 @@ pass_expand::execute (function *fun)
> FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR_FOR_FN (fun)->succs)
> e->flags &= ~EDGE_EXECUTABLE;
>
> - lab_rtx_for_bb = pointer_map_create ();
> + lab_rtx_for_bb = new hash_map<basic_block, rtx>;
> FOR_BB_BETWEEN (bb, init_block->next_bb, EXIT_BLOCK_PTR_FOR_FN (fun),
> next_bb)
> bb = expand_gimple_basic_block (bb, var_ret_seq != NULL_RTX);
> @@ -5816,7 +5827,7 @@ pass_expand::execute (function *fun)
>
> /* Expansion is used by optimization passes too, set maybe_hot_insn_p
> conservatively to true until they are all profile aware. */
> - pointer_map_destroy (lab_rtx_for_bb);
> + delete lab_rtx_for_bb;
> free_histograms ();
>
> construct_exit_block ();
> diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
> index ffb44d11ae..ec79c23 100644
> --- a/gcc/cp/cp-tree.h
> +++ b/gcc/cp/cp-tree.h
> @@ -25,6 +25,7 @@ along with GCC; see the file COPYING3. If not see
> #include "function.h"
> #include "hashtab.h"
> #include "vec.h"
> +#include "hash-map.h"
>
> /* In order for the format checking to accept the C++ front end
> diagnostic framework extensions, you must include this file before
> @@ -1064,7 +1065,7 @@ struct GTY(()) saved_scope {
> cp_binding_level *class_bindings;
> cp_binding_level *bindings;
>
> - struct pointer_map_t *x_local_specializations;
> + hash_map<tree, tree> *GTY((skip)) x_local_specializations;
>
> struct saved_scope *prev;
> };
> diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
> index 57e7216..f3cfe66 100644
> --- a/gcc/cp/pt.c
> +++ b/gcc/cp/pt.c
> @@ -1112,13 +1112,11 @@ retrieve_specialization (tree tmpl, tree args, hashval_t hash)
> static tree
> retrieve_local_specialization (tree tmpl)
> {
> - void **slot;
> -
> if (local_specializations == NULL)
> return NULL_TREE;
>
> - slot = pointer_map_contains (local_specializations, tmpl);
> - return slot ? (tree) *slot : NULL_TREE;
> + tree *slot = local_specializations->get (tmpl);
> + return slot ? *slot : NULL_TREE;
> }
>
> /* Returns nonzero iff DECL is a specialization of TMPL. */
> @@ -1730,10 +1728,7 @@ reregister_specialization (tree spec, tree tinfo, tree new_spec)
> static void
> register_local_specialization (tree spec, tree tmpl)
> {
> - void **slot;
> -
> - slot = pointer_map_insert (local_specializations, tmpl);
> - *slot = spec;
> + local_specializations->put (tmpl, spec);
> }
>
> /* TYPE is a class type. Returns true if TYPE is an explicitly
> @@ -9770,7 +9765,7 @@ tsubst_pack_expansion (tree t, tree args, tsubst_flags_t complain,
> bool unsubstituted_packs = false;
> int i, len = -1;
> tree result;
> - struct pointer_map_t *saved_local_specializations = NULL;
> + hash_map<tree, tree> *saved_local_specializations = NULL;
> bool need_local_specializations = false;
> int levels;
>
> @@ -9924,7 +9919,7 @@ tsubst_pack_expansion (tree t, tree args, tsubst_flags_t complain,
> case of recursive unification) might have bindings that we don't
> want to use or alter. */
> saved_local_specializations = local_specializations;
> - local_specializations = pointer_map_create ();
> + local_specializations = new hash_map<tree, tree>;
> }
>
> /* For each argument in each argument pack, substitute into the
> @@ -9973,7 +9968,7 @@ tsubst_pack_expansion (tree t, tree args, tsubst_flags_t complain,
>
> if (need_local_specializations)
> {
> - pointer_map_destroy (local_specializations);
> + delete local_specializations;
> local_specializations = saved_local_specializations;
> }
>
> @@ -20087,7 +20082,7 @@ instantiate_decl (tree d, int defer_ok,
> synthesize_method (d);
> else if (TREE_CODE (d) == FUNCTION_DECL)
> {
> - struct pointer_map_t *saved_local_specializations;
> + hash_map<tree, tree> *saved_local_specializations;
> tree subst_decl;
> tree tmpl_parm;
> tree spec_parm;
> @@ -20098,7 +20093,7 @@ instantiate_decl (tree d, int defer_ok,
> saved_local_specializations = local_specializations;
>
> /* Set up the list of local specializations. */
> - local_specializations = pointer_map_create ();
> + local_specializations = new hash_map<tree, tree>;
>
> /* Set up context. */
> if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern)
> @@ -20162,7 +20157,7 @@ instantiate_decl (tree d, int defer_ok,
> }
>
> /* We don't need the local specializations any more. */
> - pointer_map_destroy (local_specializations);
> + delete local_specializations;
> local_specializations = saved_local_specializations;
>
> /* Finish the function. */
> diff --git a/gcc/dse.c b/gcc/dse.c
> index 53bf28d..6370c97 100644
> --- a/gcc/dse.c
> +++ b/gcc/dse.c
> @@ -986,10 +986,9 @@ local_variable_can_escape (tree decl)
> of the escape analysis. */
> if (cfun->gimple_df->decls_to_pointers != NULL)
> {
> - void *namep
> - = pointer_map_contains (cfun->gimple_df->decls_to_pointers, decl);
> + tree *namep = cfun->gimple_df->decls_to_pointers->get (decl);
> if (namep)
> - return TREE_ADDRESSABLE (*(tree *)namep);
> + return TREE_ADDRESSABLE (*namep);
> }
>
> return false;
> diff --git a/gcc/except.h b/gcc/except.h
> index 5c2aa3d..9bdb6bd 100644
> --- a/gcc/except.h
> +++ b/gcc/except.h
> @@ -30,7 +30,6 @@ along with GCC; see the file COPYING3. If not see
>
> struct function;
> struct eh_region_d;
> -struct pointer_map_t;
>
> /* The type of an exception region. */
> enum eh_region_type
> diff --git a/gcc/gimple-expr.c b/gcc/gimple-expr.c
> index da663d6..73285b2 100644
> --- a/gcc/gimple-expr.c
> +++ b/gcc/gimple-expr.c
> @@ -883,10 +883,9 @@ mark_addressable (tree x)
> && cfun->gimple_df != NULL
> && cfun->gimple_df->decls_to_pointers != NULL)
> {
> - void *namep
> - = pointer_map_contains (cfun->gimple_df->decls_to_pointers, x);
> + tree *namep = cfun->gimple_df->decls_to_pointers->get (x);
> if (namep)
> - TREE_ADDRESSABLE (*(tree *)namep) = 1;
> + TREE_ADDRESSABLE (*namep) = 1;
> }
> }
>
> diff --git a/gcc/gimple-ssa-strength-reduction.c b/gcc/gimple-ssa-strength-reduction.c
> index b13b7f7..a9e0161 100644
> --- a/gcc/gimple-ssa-strength-reduction.c
> +++ b/gcc/gimple-ssa-strength-reduction.c
> @@ -434,7 +434,7 @@ cand_chain_hasher::equal (const value_type *chain1, const compare_type *chain2)
> static hash_table<cand_chain_hasher> *base_cand_map;
>
> /* Pointer map used by tree_to_aff_combination_expand. */
> -static struct pointer_map_t *name_expansions;
> +static hash_map<tree, name_expansion *> *name_expansions;
> /* Pointer map embodying a mapping from bases to alternative bases. */
> static hash_map<tree, tree> *alt_base_map;
>
> diff --git a/gcc/gimple-ssa.h b/gcc/gimple-ssa.h
> index 904f002..d2e62a9 100644
> --- a/gcc/gimple-ssa.h
> +++ b/gcc/gimple-ssa.h
> @@ -21,6 +21,7 @@ along with GCC; see the file COPYING3. If not see
> #ifndef GCC_GIMPLE_SSA_H
> #define GCC_GIMPLE_SSA_H
>
> +#include "hash-map.h"
> #include "tree-ssa-operands.h"
>
> /* This structure is used to map a gimple statement to a label,
> @@ -53,7 +54,7 @@ struct GTY(()) gimple_df {
>
> /* A map of decls to artificial ssa-names that point to the partition
> of the decl. */
> - struct pointer_map_t * GTY((skip(""))) decls_to_pointers;
> + hash_map<tree, tree> * GTY((skip(""))) decls_to_pointers;
>
> /* Free list of SSA_NAMEs. */
> vec<tree, va_gc> *free_ssanames;
> diff --git a/gcc/hash-map.h b/gcc/hash-map.h
> index ec48844..d2eed33 100644
> --- a/gcc/hash-map.h
> +++ b/gcc/hash-map.h
> @@ -36,12 +36,9 @@ struct default_hashmap_traits
> return uintptr_t(p) >> 3;
> }
>
> - /* The right thing to do here would be using is_integral to only allow
> - template arguments of integer type, but reimplementing that is a pain, so
> - we'll just promote everything to [u]int64_t and truncate to hashval_t. */
> + /* If the value converts to hashval_t just use it. */
>
> - static hashval_t hash (uint64_t v) { return v; }
> - static hashval_t hash (int64_t v) { return v; }
> + template<typename T> static hashval_t hash (T v) { return v; }
>
> /* Return true if the two keys passed as arguments are equal. */
>
> diff --git a/gcc/ifcvt.c b/gcc/ifcvt.c
> index faf9b30..e9f56c1 100644
> --- a/gcc/ifcvt.c
> +++ b/gcc/ifcvt.c
> @@ -2727,7 +2727,7 @@ noce_process_if_block (struct noce_if_info *if_info)
>
> static int
> check_cond_move_block (basic_block bb,
> - struct pointer_map_t *vals,
> + hash_map<rtx, rtx> *vals,
> vec<rtx> *regs,
> rtx cond)
> {
> @@ -2742,7 +2742,6 @@ check_cond_move_block (basic_block bb,
> FOR_BB_INSNS (bb, insn)
> {
> rtx set, dest, src;
> - void **slot;
>
> if (!NONDEBUG_INSN_P (insn) || JUMP_P (insn))
> continue;
> @@ -2769,14 +2768,14 @@ check_cond_move_block (basic_block bb,
> /* Don't try to handle this if the source register was
> modified earlier in the block. */
> if ((REG_P (src)
> - && pointer_map_contains (vals, src))
> + && vals->get (src))
> || (GET_CODE (src) == SUBREG && REG_P (SUBREG_REG (src))
> - && pointer_map_contains (vals, SUBREG_REG (src))))
> + && vals->get (SUBREG_REG (src))))
> return FALSE;
>
> /* Don't try to handle this if the destination register was
> modified earlier in the block. */
> - if (pointer_map_contains (vals, dest))
> + if (vals->get (dest))
> return FALSE;
>
> /* Don't try to handle this if the condition uses the
> @@ -2790,8 +2789,7 @@ check_cond_move_block (basic_block bb,
> && modified_between_p (src, insn, NEXT_INSN (BB_END (bb))))
> return FALSE;
>
> - slot = pointer_map_insert (vals, (void *) dest);
> - *slot = (void *) src;
> + vals->put (dest, src);
>
> regs->safe_push (dest);
> }
> @@ -2809,8 +2807,8 @@ check_cond_move_block (basic_block bb,
> static bool
> cond_move_convert_if_block (struct noce_if_info *if_infop,
> basic_block bb, rtx cond,
> - struct pointer_map_t *then_vals,
> - struct pointer_map_t *else_vals,
> + hash_map<rtx, rtx> *then_vals,
> + hash_map<rtx, rtx> *else_vals,
> bool else_block_p)
> {
> enum rtx_code code;
> @@ -2823,7 +2821,6 @@ cond_move_convert_if_block (struct noce_if_info *if_infop,
> FOR_BB_INSNS (bb, insn)
> {
> rtx set, target, dest, t, e;
> - void **then_slot, **else_slot;
>
> /* ??? Maybe emit conditional debug insn? */
> if (!NONDEBUG_INSN_P (insn) || JUMP_P (insn))
> @@ -2833,10 +2830,10 @@ cond_move_convert_if_block (struct noce_if_info *if_infop,
>
> dest = SET_DEST (set);
>
> - then_slot = pointer_map_contains (then_vals, dest);
> - else_slot = pointer_map_contains (else_vals, dest);
> - t = then_slot ? (rtx) *then_slot : NULL_RTX;
> - e = else_slot ? (rtx) *else_slot : NULL_RTX;
> + rtx *then_slot = then_vals->get (dest);
> + rtx *else_slot = else_vals->get (dest);
> + t = then_slot ? *then_slot : NULL_RTX;
> + e = else_slot ? *else_slot : NULL_RTX;
>
> if (else_block_p)
> {
> @@ -2882,8 +2879,6 @@ cond_move_process_if_block (struct noce_if_info *if_info)
> rtx seq, loc_insn;
> rtx reg;
> int c;
> - struct pointer_map_t *then_vals;
> - struct pointer_map_t *else_vals;
> vec<rtx> then_regs = vNULL;
> vec<rtx> else_regs = vNULL;
> unsigned int i;
> @@ -2891,13 +2886,13 @@ cond_move_process_if_block (struct noce_if_info *if_info)
>
> /* Build a mapping for each block to the value used for each
> register. */
> - then_vals = pointer_map_create ();
> - else_vals = pointer_map_create ();
> + hash_map<rtx, rtx> then_vals;
> + hash_map<rtx, rtx> else_vals;
>
> /* Make sure the blocks are suitable. */
> - if (!check_cond_move_block (then_bb, then_vals, &then_regs, cond)
> + if (!check_cond_move_block (then_bb, &then_vals, &then_regs, cond)
> || (else_bb
> - && !check_cond_move_block (else_bb, else_vals, &else_regs, cond)))
> + && !check_cond_move_block (else_bb, &else_vals, &else_regs, cond)))
> goto done;
>
> /* Make sure the blocks can be used together. If the same register
> @@ -2909,16 +2904,16 @@ cond_move_process_if_block (struct noce_if_info *if_info)
> c = 0;
> FOR_EACH_VEC_ELT (then_regs, i, reg)
> {
> - void **then_slot = pointer_map_contains (then_vals, reg);
> - void **else_slot = pointer_map_contains (else_vals, reg);
> + rtx *then_slot = then_vals.get (reg);
> + rtx *else_slot = else_vals.get (reg);
>
> gcc_checking_assert (then_slot);
> if (!else_slot)
> ++c;
> else
> {
> - rtx then_val = (rtx) *then_slot;
> - rtx else_val = (rtx) *else_slot;
> + rtx then_val = *then_slot;
> + rtx else_val = *else_slot;
> if (!CONSTANT_P (then_val) && !CONSTANT_P (else_val)
> && !rtx_equal_p (then_val, else_val))
> goto done;
> @@ -2928,8 +2923,8 @@ cond_move_process_if_block (struct noce_if_info *if_info)
> /* Finish off c for MAX_CONDITIONAL_EXECUTE. */
> FOR_EACH_VEC_ELT (else_regs, i, reg)
> {
> - gcc_checking_assert (pointer_map_contains (else_vals, reg));
> - if (!pointer_map_contains (then_vals, reg))
> + gcc_checking_assert (else_vals.get (reg));
> + if (!then_vals.get (reg))
> ++c;
> }
>
> @@ -2944,10 +2939,10 @@ cond_move_process_if_block (struct noce_if_info *if_info)
> then do anything left in the else blocks. */
> start_sequence ();
> if (!cond_move_convert_if_block (if_info, then_bb, cond,
> - then_vals, else_vals, false)
> + &then_vals, &else_vals, false)
> || (else_bb
> && !cond_move_convert_if_block (if_info, else_bb, cond,
> - then_vals, else_vals, true)))
> + &then_vals, &else_vals, true)))
> {
> end_sequence ();
> goto done;
> @@ -2988,8 +2983,6 @@ cond_move_process_if_block (struct noce_if_info *if_info)
> success_p = TRUE;
>
> done:
> - pointer_map_destroy (then_vals);
> - pointer_map_destroy (else_vals);
> then_regs.release ();
> else_regs.release ();
> return success_p;
> diff --git a/gcc/lto-streamer-out.c b/gcc/lto-streamer-out.c
> index 81a7b23..d6fec4c 100644
> --- a/gcc/lto-streamer-out.c
> +++ b/gcc/lto-streamer-out.c
> @@ -475,7 +475,7 @@ private:
> hash_scc (struct output_block *ob, unsigned first, unsigned size);
>
> unsigned int next_dfs_num;
> - struct pointer_map_t *sccstate;
> + hash_map<tree, sccs *> sccstate;
> struct obstack sccstate_obstack;
> };
>
> @@ -483,7 +483,6 @@ DFS::DFS (struct output_block *ob, tree expr, bool ref_p, bool this_ref_p,
> bool single_p)
> {
> sccstack.create (0);
> - sccstate = pointer_map_create ();
> gcc_obstack_init (&sccstate_obstack);
> next_dfs_num = 1;
> DFS_write_tree (ob, NULL, expr, ref_p, this_ref_p, single_p);
> @@ -492,7 +491,6 @@ DFS::DFS (struct output_block *ob, tree expr, bool ref_p, bool this_ref_p,
> DFS::~DFS ()
> {
> sccstack.release ();
> - pointer_map_destroy (sccstate);
> obstack_free (&sccstate_obstack, NULL);
> }
>
> @@ -1314,7 +1312,6 @@ DFS::DFS_write_tree (struct output_block *ob, sccs *from_state,
> tree expr, bool ref_p, bool this_ref_p, bool single_p)
> {
> unsigned ix;
> - sccs **slot;
>
> /* Handle special cases. */
> if (expr == NULL_TREE)
> @@ -1328,7 +1325,7 @@ DFS::DFS_write_tree (struct output_block *ob, sccs *from_state,
> if (streamer_tree_cache_lookup (ob->writer_cache, expr, &ix))
> return;
>
> - slot = (sccs **)pointer_map_insert (sccstate, expr);
> + sccs **slot = &sccstate.get_or_insert (expr);
> sccs *cstate = *slot;
> if (!cstate)
> {
> diff --git a/gcc/lto-streamer.h b/gcc/lto-streamer.h
> index 7cab1cb..f304ba2 100644
> --- a/gcc/lto-streamer.h
> +++ b/gcc/lto-streamer.h
> @@ -561,7 +561,7 @@ struct GTY(()) lto_file_decl_data
> struct gcov_ctr_summary GTY((skip)) profile_info;
>
> /* Map assigning declarations their resolutions. */
> - pointer_map_t * GTY((skip)) resolution_map;
> + hash_map<tree, ld_plugin_symbol_resolution> * GTY((skip)) resolution_map;
> };
>
> typedef struct lto_file_decl_data *lto_file_decl_data_ptr;
> diff --git a/gcc/lto/lto-partition.c b/gcc/lto/lto-partition.c
> index a5bcf92..1837b99 100644
> --- a/gcc/lto/lto-partition.c
> +++ b/gcc/lto/lto-partition.c
> @@ -268,13 +268,10 @@ lto_1_to_1_map (void)
> {
> symtab_node *node;
> struct lto_file_decl_data *file_data;
> - struct pointer_map_t *pmap;
> + hash_map<lto_file_decl_data *, ltrans_partition> pmap;
> ltrans_partition partition;
> - void **slot;
> int npartitions = 0;
>
> - pmap = pointer_map_create ();
> -
> FOR_EACH_SYMBOL (node)
> {
> if (node->get_partitioning_class () != SYMBOL_PARTITION
> @@ -285,13 +282,12 @@ lto_1_to_1_map (void)
>
> if (file_data)
> {
> - slot = pointer_map_contains (pmap, file_data);
> - if (slot)
> - partition = (ltrans_partition) *slot;
> + ltrans_partition *slot = &pmap.get_or_insert (file_data);
> + if (*slot)
> + partition = *slot;
> else
> {
> partition = new_partition (file_data->file_name);
> - slot = pointer_map_insert (pmap, file_data);
> *slot = partition;
> npartitions++;
> }
> @@ -301,8 +297,7 @@ lto_1_to_1_map (void)
> else
> {
> partition = new_partition ("");
> - slot = pointer_map_insert (pmap, NULL);
> - *slot = partition;
> + pmap.put (NULL, partition);
> npartitions++;
> }
>
> @@ -314,8 +309,6 @@ lto_1_to_1_map (void)
> if (!npartitions)
> new_partition ("empty");
>
> - pointer_map_destroy (pmap);
> -
> }
>
> /* Maximal partitioning. Put every new symbol into new partition if possible. */
> diff --git a/gcc/lto/lto.c b/gcc/lto/lto.c
> index 7ecdec2..6f864d9 100644
> --- a/gcc/lto/lto.c
> +++ b/gcc/lto/lto.c
> @@ -1007,8 +1007,9 @@ register_resolution (struct lto_file_decl_data *file_data, tree decl,
> if (resolution == LDPR_UNKNOWN)
> return;
> if (!file_data->resolution_map)
> - file_data->resolution_map = pointer_map_create ();
> - *pointer_map_insert (file_data->resolution_map, decl) = (void *)(size_t)resolution;
> + file_data->resolution_map
> + = new hash_map<tree, ld_plugin_symbol_resolution>;
> + file_data->resolution_map->put (decl, resolution);
> }
>
> /* Register DECL with the global symbol table and change its
> @@ -2887,7 +2888,6 @@ read_cgraph_and_symbols (unsigned nfiles, const char **fnames)
> FILE *resolution;
> int count = 0;
> struct lto_file_decl_data **decl_data;
> - void **res;
> symtab_node *snode;
>
> init_cgraph ();
> @@ -3014,18 +3014,17 @@ read_cgraph_and_symbols (unsigned nfiles, const char **fnames)
>
> /* Store resolutions into the symbol table. */
>
> + ld_plugin_symbol_resolution_t *res;
> FOR_EACH_SYMBOL (snode)
> if (snode->real_symbol_p ()
> && snode->lto_file_data
> && snode->lto_file_data->resolution_map
> - && (res = pointer_map_contains (snode->lto_file_data->resolution_map,
> - snode->decl)))
> - snode->resolution
> - = (enum ld_plugin_symbol_resolution)(size_t)*res;
> + && (res = snode->lto_file_data->resolution_map->get (snode->decl)))
> + snode->resolution = *res;
> for (i = 0; all_file_decl_data[i]; i++)
> if (all_file_decl_data[i]->resolution_map)
> {
> - pointer_map_destroy (all_file_decl_data[i]->resolution_map);
> + delete all_file_decl_data[i]->resolution_map;
> all_file_decl_data[i]->resolution_map = NULL;
> }
>
> diff --git a/gcc/tree-affine.c b/gcc/tree-affine.c
> index 0b85778..5c894ea 100644
> --- a/gcc/tree-affine.c
> +++ b/gcc/tree-affine.c
> @@ -621,14 +621,13 @@ struct name_expansion
>
> void
> aff_combination_expand (aff_tree *comb ATTRIBUTE_UNUSED,
> - struct pointer_map_t **cache ATTRIBUTE_UNUSED)
> + hash_map<tree, name_expansion *> **cache)
> {
> unsigned i;
> aff_tree to_add, current, curre;
> tree e, rhs;
> gimple def;
> widest_int scale;
> - void **slot;
> struct name_expansion *exp;
>
> aff_combination_zero (&to_add, comb->type);
> @@ -664,9 +663,9 @@ aff_combination_expand (aff_tree *comb ATTRIBUTE_UNUSED,
> continue;
>
> if (!*cache)
> - *cache = pointer_map_create ();
> - slot = pointer_map_insert (*cache, e);
> - exp = (struct name_expansion *) *slot;
> + *cache = new hash_map<tree, name_expansion *>;
> + name_expansion **slot = &(*cache)->get_or_insert (e);
> + exp = *slot;
>
> if (!exp)
> {
> @@ -732,22 +731,19 @@ aff_combination_expand (aff_tree *comb ATTRIBUTE_UNUSED,
>
> void
> tree_to_aff_combination_expand (tree expr, tree type, aff_tree *comb,
> - struct pointer_map_t **cache)
> + hash_map<tree, name_expansion *> **cache)
> {
> tree_to_aff_combination (expr, type, comb);
> aff_combination_expand (comb, cache);
> }
>
> /* Frees memory occupied by struct name_expansion in *VALUE. Callback for
> - pointer_map_traverse. */
> + hash_map::traverse. */
>
> -static bool
> -free_name_expansion (const void *key ATTRIBUTE_UNUSED, void **value,
> - void *data ATTRIBUTE_UNUSED)
> +bool
> +free_name_expansion (tree const &, name_expansion **value, void *)
> {
> - struct name_expansion *const exp = (struct name_expansion *) *value;
> -
> - free (exp);
> + free (*value);
> return true;
> }
>
> @@ -755,13 +751,13 @@ free_name_expansion (const void *key ATTRIBUTE_UNUSED, void **value,
> tree_to_aff_combination_expand. */
>
> void
> -free_affine_expand_cache (struct pointer_map_t **cache)
> +free_affine_expand_cache (hash_map<tree, name_expansion *> **cache)
> {
> if (!*cache)
> return;
>
> - pointer_map_traverse (*cache, free_name_expansion, NULL);
> - pointer_map_destroy (*cache);
> + (*cache)->traverse<void *, free_name_expansion> (NULL);
> + delete (*cache);
> *cache = NULL;
> }
>
> diff --git a/gcc/tree-affine.h b/gcc/tree-affine.h
> index 8c9d990..48dd2a7 100644
> --- a/gcc/tree-affine.h
> +++ b/gcc/tree-affine.h
> @@ -20,6 +20,7 @@ along with GCC; see the file COPYING3. If not see
> /* Affine combination of trees. We keep track of at most MAX_AFF_ELTS elements
> to make things simpler; this is sufficient in most cases. */
>
> +#include "hash-map.h"
> #include "wide-int.h"
>
> #define MAX_AFF_ELTS 8
> @@ -60,6 +61,8 @@ struct aff_tree
> tree rest;
> };
>
> +struct name_expansion;
> +
> widest_int wide_int_ext_for_comb (const widest_int &, aff_tree *);
> void aff_combination_const (aff_tree *, tree, const widest_int &);
> void aff_combination_elt (aff_tree *, tree, tree);
> @@ -73,11 +76,11 @@ void tree_to_aff_combination (tree, tree, aff_tree *);
> tree aff_combination_to_tree (aff_tree *);
> void unshare_aff_combination (aff_tree *);
> bool aff_combination_constant_multiple_p (aff_tree *, aff_tree *, widest_int *);
> -void aff_combination_expand (aff_tree *, struct pointer_map_t **);
> +void aff_combination_expand (aff_tree *, hash_map<tree, name_expansion *> **);
> void tree_to_aff_combination_expand (tree, tree, aff_tree *,
> - struct pointer_map_t **);
> + hash_map<tree, name_expansion *> **);
> tree get_inner_reference_aff (tree, aff_tree *, widest_int *);
> -void free_affine_expand_cache (struct pointer_map_t **);
> +void free_affine_expand_cache (hash_map<tree, name_expansion *> **);
> bool aff_comb_cannot_overlap_p (aff_tree *, const widest_int &,
> const widest_int &);
>
> diff --git a/gcc/tree-predcom.c b/gcc/tree-predcom.c
> index ecea3ed..7348985 100644
> --- a/gcc/tree-predcom.c
> +++ b/gcc/tree-predcom.c
> @@ -350,7 +350,7 @@ static bitmap looparound_phis;
>
> /* Cache used by tree_to_aff_combination_expand. */
>
> -static struct pointer_map_t *name_expansions;
> +static hash_map<tree, name_expansion *> *name_expansions;
>
> /* Dumps data reference REF to FILE. */
>
> diff --git a/gcc/tree-scalar-evolution.c b/gcc/tree-scalar-evolution.c
> index 3890f95..3c40b00 100644
> --- a/gcc/tree-scalar-evolution.c
> +++ b/gcc/tree-scalar-evolution.c
> @@ -1403,7 +1403,7 @@ simplify_peeled_chrec (struct loop *loop, tree arg, tree init_cond)
> {
> aff_tree aff1, aff2;
> tree ev, left, right, type, step_val;
> - pointer_map_t *peeled_chrec_map = NULL;
> + hash_map<tree, name_expansion *> *peeled_chrec_map = NULL;
>
> ev = instantiate_parameters (loop, analyze_scalar_evolution (loop, arg));
> if (ev == NULL_TREE || TREE_CODE (ev) != POLYNOMIAL_CHREC)
> diff --git a/gcc/tree-ssa-loop-im.c b/gcc/tree-ssa-loop-im.c
> index 0cbb3ae..6239a70 100644
> --- a/gcc/tree-ssa-loop-im.c
> +++ b/gcc/tree-ssa-loop-im.c
> @@ -200,7 +200,7 @@ static struct
> vec<bitmap_head> all_refs_stored_in_loop;
>
> /* Cache for expanding memory addresses. */
> - struct pointer_map_t *ttae_cache;
> + hash_map<tree, name_expansion *> *ttae_cache;
> } memory_accesses;
>
> /* Obstack for the bitmaps in the above data structures. */
> @@ -1610,7 +1610,7 @@ analyze_memory_references (void)
>
> static bool
> mem_refs_may_alias_p (mem_ref_p mem1, mem_ref_p mem2,
> - struct pointer_map_t **ttae_cache)
> + hash_map<tree, name_expansion *> **ttae_cache)
> {
> /* Perform BASE + OFFSET analysis -- if MEM1 and MEM2 are based on the same
> object and their offset differ in such a way that the locations cannot
> diff --git a/gcc/tree-ssa-loop-niter.c b/gcc/tree-ssa-loop-niter.c
> index 83c1b19..c95cde8 100644
> --- a/gcc/tree-ssa-loop-niter.c
> +++ b/gcc/tree-ssa-loop-niter.c
> @@ -3108,14 +3108,12 @@ bound_index (vec<widest_int> bounds, const widest_int &bound)
> static void
> discover_iteration_bound_by_body_walk (struct loop *loop)
> {
> - pointer_map_t *bb_bounds;
> struct nb_iter_bound *elt;
> vec<widest_int> bounds = vNULL;
> vec<vec<basic_block> > queues = vNULL;
> vec<basic_block> queue = vNULL;
> ptrdiff_t queue_index;
> ptrdiff_t latch_index = 0;
> - pointer_map_t *block_priority;
>
> /* Discover what bounds may interest us. */
> for (elt = loop->bounds; elt; elt = elt->next)
> @@ -3150,7 +3148,7 @@ discover_iteration_bound_by_body_walk (struct loop *loop)
> /* For every basic block record the lowest bound that is guaranteed to
> terminate the loop. */
>
> - bb_bounds = pointer_map_create ();
> + hash_map<basic_block, ptrdiff_t> bb_bounds;
> for (elt = loop->bounds; elt; elt = elt->next)
> {
> widest_int bound = elt->bound;
> @@ -3166,17 +3164,15 @@ discover_iteration_bound_by_body_walk (struct loop *loop)
> || wi::ltu_p (bound, loop->nb_iterations_upper_bound))
> {
> ptrdiff_t index = bound_index (bounds, bound);
> - void **entry = pointer_map_contains (bb_bounds,
> - gimple_bb (elt->stmt));
> + ptrdiff_t *entry = bb_bounds.get (gimple_bb (elt->stmt));
> if (!entry)
> - *pointer_map_insert (bb_bounds,
> - gimple_bb (elt->stmt)) = (void *)index;
> + bb_bounds.put (gimple_bb (elt->stmt), index);
> else if ((ptrdiff_t)*entry > index)
> - *entry = (void *)index;
> + *entry = index;
> }
> }
>
> - block_priority = pointer_map_create ();
> + hash_map<basic_block, ptrdiff_t> block_priority;
>
> /* Perform shortest path discovery loop->header ... loop->latch.
>
> @@ -3199,7 +3195,7 @@ discover_iteration_bound_by_body_walk (struct loop *loop)
> queues.safe_grow_cleared (queue_index + 1);
> queue.safe_push (loop->header);
> queues[queue_index] = queue;
> - *pointer_map_insert (block_priority, loop->header) = (void *)queue_index;
> + block_priority.put (loop->header, queue_index);
>
> for (; queue_index >= 0; queue_index--)
> {
> @@ -3209,7 +3205,6 @@ discover_iteration_bound_by_body_walk (struct loop *loop)
> {
> basic_block bb;
> ptrdiff_t bound_index = queue_index;
> - void **entry;
> edge e;
> edge_iterator ei;
>
> @@ -3217,20 +3212,19 @@ discover_iteration_bound_by_body_walk (struct loop *loop)
> bb = queue.pop ();
>
> /* OK, we later inserted the BB with lower priority, skip it. */
> - if ((ptrdiff_t)*pointer_map_contains (block_priority, bb) > queue_index)
> + if (*block_priority.get (bb) > queue_index)
> continue;
>
> /* See if we can improve the bound. */
> - entry = pointer_map_contains (bb_bounds, bb);
> - if (entry && (ptrdiff_t)*entry < bound_index)
> - bound_index = (ptrdiff_t)*entry;
> + ptrdiff_t *entry = bb_bounds.get (bb);
> + if (entry && *entry < bound_index)
> + bound_index = *entry;
>
> /* Insert succesors into the queue, watch for latch edge
> and record greatest index we saw. */
> FOR_EACH_EDGE (e, ei, bb->succs)
> {
> bool insert = false;
> - void **entry;
>
> if (loop_exit_edge_p (loop, e))
> continue;
> @@ -3238,15 +3232,15 @@ discover_iteration_bound_by_body_walk (struct loop *loop)
> if (e == loop_latch_edge (loop)
> && latch_index < bound_index)
> latch_index = bound_index;
> - else if (!(entry = pointer_map_contains (block_priority, e->dest)))
> + else if (!(entry = block_priority.get (e->dest)))
> {
> insert = true;
> - *pointer_map_insert (block_priority, e->dest) = (void *)bound_index;
> + block_priority.put (e->dest, bound_index);
> }
> - else if ((ptrdiff_t)*entry < bound_index)
> + else if (*entry < bound_index)
> {
> insert = true;
> - *entry = (void *)bound_index;
> + *entry = bound_index;
> }
>
> if (insert)
> @@ -3271,8 +3265,6 @@ discover_iteration_bound_by_body_walk (struct loop *loop)
>
> queues.release ();
> bounds.release ();
> - pointer_map_destroy (bb_bounds);
> - pointer_map_destroy (block_priority);
> }
>
> /* See if every path cross the loop goes through a statement that is known
> diff --git a/gcc/tree-ssa.c b/gcc/tree-ssa.c
> index e684296..fd12be7 100644
> --- a/gcc/tree-ssa.c
> +++ b/gcc/tree-ssa.c
> @@ -1158,7 +1158,7 @@ delete_tree_ssa (void)
> cfun->gimple_df->default_defs = NULL;
> pt_solution_reset (&cfun->gimple_df->escaped);
> if (cfun->gimple_df->decls_to_pointers != NULL)
> - pointer_map_destroy (cfun->gimple_df->decls_to_pointers);
> + delete cfun->gimple_df->decls_to_pointers;
> cfun->gimple_df->decls_to_pointers = NULL;
> cfun->gimple_df->modified_noreturn_calls = NULL;
> cfun->gimple_df = NULL;
> diff --git a/gcc/value-prof.c b/gcc/value-prof.c
> index ffdee65..e357967 100644
> --- a/gcc/value-prof.c
> +++ b/gcc/value-prof.c
> @@ -1209,7 +1209,22 @@ gimple_mod_subtract_transform (gimple_stmt_iterator *si)
> return true;
> }
>
> -static pointer_map_t *cgraph_node_map = 0;
> +struct profile_id_traits : default_hashmap_traits
> +{
> + template<typename T>
> + static bool
> + is_deleted (T &e)
> + {
> + return e.m_key == UINT_MAX;
> + }
> +
> + template<typename T> static bool is_empty (T &e) { return e.m_key == 0; }
> + template<typename T> static void mark_deleted (T &e) { e.m_key = UINT_MAX; }
> + template<typename T> static void mark_empty (T &e) { e.m_key = 0; }
> +};
> +
> +static hash_map<unsigned int, cgraph_node *, profile_id_traits> *
> +cgraph_node_map = 0;
>
> /* Returns true if node graph is initialized. This
> is used to test if profile_id has been created
> @@ -1229,17 +1244,17 @@ void
> init_node_map (bool local)
> {
> struct cgraph_node *n;
> - cgraph_node_map = pointer_map_create ();
> + cgraph_node_map
> + = new hash_map<unsigned int, cgraph_node *, profile_id_traits>;
>
> FOR_EACH_DEFINED_FUNCTION (n)
> if (n->has_gimple_body_p ())
> {
> - void **val;
> + cgraph_node **val;
> if (local)
> {
> n->profile_id = coverage_compute_profile_id (n);
> - while ((val = pointer_map_contains (cgraph_node_map,
> - (void *)(size_t)n->profile_id))
> + while ((val = cgraph_node_map->get (n->profile_id))
> || !n->profile_id)
> {
> if (dump_file)
> @@ -1248,8 +1263,8 @@ init_node_map (bool local)
> n->profile_id,
> n->name (),
> n->order,
> - (*(symtab_node **)val)->name (),
> - (*(symtab_node **)val)->order);
> + (*val)->name (),
> + (*val)->order);
> n->profile_id = (n->profile_id + 1) & 0x7fffffff;
> }
> }
> @@ -1263,8 +1278,7 @@ init_node_map (bool local)
> n->order);
> continue;
> }
> - else if ((val = pointer_map_contains (cgraph_node_map,
> - (void *)(size_t)n->profile_id)))
> + else if ((val = cgraph_node_map->get (n->profile_id)))
> {
> if (dump_file)
> fprintf (dump_file,
> @@ -1276,8 +1290,7 @@ init_node_map (bool local)
> *val = NULL;
> continue;
> }
> - *pointer_map_insert (cgraph_node_map,
> - (void *)(size_t)n->profile_id) = (void *)n;
> + cgraph_node_map->put (n->profile_id, n);
> }
> }
>
> @@ -1286,7 +1299,7 @@ init_node_map (bool local)
> void
> del_node_map (void)
> {
> - pointer_map_destroy (cgraph_node_map);
> + delete cgraph_node_map;
> }
>
> /* Return cgraph node for function with pid */
> @@ -1294,10 +1307,9 @@ del_node_map (void)
> struct cgraph_node*
> find_func_by_profile_id (int profile_id)
> {
> - void **val = pointer_map_contains (cgraph_node_map,
> - (void *)(size_t)profile_id);
> + cgraph_node **val = cgraph_node_map->get (profile_id);
> if (val)
> - return (struct cgraph_node *)*val;
> + return *val;
> else
> return NULL;
> }
> --
> 2.0.1
>