| Message ID | 1429245495-3519-1-git-send-email-tbsaunde+gcc@tbsaunde.org |
|---|---|
| State | New |
| Headers | show |
On Fri, Apr 17, 2015 at 6:38 AM, <tbsaunde+gcc@tbsaunde.org> wrote: > From: Trevor Saunders <tbsaunde+gcc@tbsaunde.org> > > Hi, > > Last stage 1 I introduced a second form of hash_table that stored elements of > value_type in addition to the old form that stored elements of type value_type > *. That lead to a fair bit of code dupplication in hash_table, but it > simplified the transition by allowing it to take place one hash table at a > time. Now I'm switching the rest of the hash_table users to use the new setup, > and removing supporot for the old one. > > this was bootstrapped and regtested on x86_64-unknown-linux-gnu, and I ran make > all-gcc for the following crosses to check the hash tables they use were > correctly converted > arm-linux-androideabi > i686-apple-darwin > i686-solaris2.11 > i686-w64-mingw32 > ia64-linux > mips64-linux > nvptx-elf > ppc64-linux > > Is this ok? Ok. Thanks, Richard. > Trev > > gcc/ > > * hash-table.h: Remove version of hash_table that stored value_type *. > * asan.c, attribs.c, bitmap.c, cfg.c, cgraph.h, config/arm/arm.c, > config/i386/winnt.c, config/ia64/ia64.c, config/mips/mips.c, > config/sol2.c, coverage.c, cselib.c, dse.c, dwarf2cfi.c, > dwarf2out.c, except.c, gcse.c, genmatch.c, ggc-common.c, > gimple-ssa-strength-reduction.c, gimplify.c, haifa-sched.c, > hard-reg-set.h, hash-map.h, hash-set.h, ipa-devirt.c, ipa-icf.h, > ipa-profile.c, ira-color.c, ira-costs.c, loop-invariant.c, > loop-iv.c, loop-unroll.c, lto-streamer.h, plugin.c, postreload-gcse.c, > reginfo.c, statistics.c, store-motion.c, trans-mem.c, tree-cfg.c, > tree-eh.c, tree-hasher.h, tree-into-ssa.c, tree-parloops.c, > tree-sra.c, tree-ssa-coalesce.c, tree-ssa-dom.c, tree-ssa-live.c, > tree-ssa-loop-im.c, tree-ssa-loop-ivopts.c, tree-ssa-phiopt.c, > tree-ssa-pre.c, tree-ssa-reassoc.c, tree-ssa-sccvn.c, > tree-ssa-structalias.c, tree-ssa-tail-merge.c, > tree-ssa-threadupdate.c, tree-vectorizer.c, tree-vectorizer.h, > valtrack.h, var-tracking.c, vtable-verify.c, vtable-verify.h: Adjust. > > > libcc1/ > > * plugin.cc: Adjust for hash_table changes. > > java/ > > * jcf-io.c: Adjust for hash_table changes. > > lto/ > > * lto.c: Adjust for hash_table changes. > > objc/ > > * objc-act.c: Adjust for hash_table changes. > > diff --git a/gcc/asan.c b/gcc/asan.c > index 9e4a629..7b70ee2 100644 > --- a/gcc/asan.c > +++ b/gcc/asan.c > @@ -407,11 +407,11 @@ asan_mem_ref_get_end (const asan_mem_ref *ref, tree len) > struct asan_mem_ref_hasher > : typed_noop_remove <asan_mem_ref> > { > - typedef asan_mem_ref value_type; > - typedef asan_mem_ref compare_type; > + typedef asan_mem_ref *value_type; > + typedef asan_mem_ref *compare_type; > > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + static inline hashval_t hash (const asan_mem_ref *); > + static inline bool equal (const asan_mem_ref *, const asan_mem_ref *); > }; > > /* Hash a memory reference. */ > diff --git a/gcc/attribs.c b/gcc/attribs.c > index c18bff2..7b7e2a9 100644 > --- a/gcc/attribs.c > +++ b/gcc/attribs.c > @@ -67,21 +67,21 @@ substring_hash (const char *str, int l) > > struct attribute_hasher : typed_noop_remove <attribute_spec> > { > - typedef attribute_spec value_type; > - typedef substring compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef attribute_spec *value_type; > + typedef substring *compare_type; > + static inline hashval_t hash (const attribute_spec *); > + static inline bool equal (const attribute_spec *, const substring *); > }; > > inline hashval_t > -attribute_hasher::hash (const value_type *spec) > +attribute_hasher::hash (const attribute_spec *spec) > { > const int l = strlen (spec->name); > return substring_hash (spec->name, l); > } > > inline bool > -attribute_hasher::equal (const value_type *spec, const compare_type *str) > +attribute_hasher::equal (const attribute_spec *spec, const substring *str) > { > return (strncmp (spec->name, str->str, str->length) == 0 > && !spec->name[str->length]); > diff --git a/gcc/bitmap.c b/gcc/bitmap.c > index d43a39f..71d5b11 100644 > --- a/gcc/bitmap.c > +++ b/gcc/bitmap.c > @@ -61,20 +61,20 @@ struct loc > > struct bitmap_desc_hasher : typed_noop_remove <bitmap_descriptor_d> > { > - typedef bitmap_descriptor_d value_type; > - typedef loc compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef bitmap_descriptor_d *value_type; > + typedef loc *compare_type; > + static inline hashval_t hash (const bitmap_descriptor_d *); > + static inline bool equal (const bitmap_descriptor_d *, const loc *); > }; > > inline hashval_t > -bitmap_desc_hasher::hash (const value_type *d) > +bitmap_desc_hasher::hash (const bitmap_descriptor_d *d) > { > return htab_hash_pointer (d->file) + d->line; > } > > inline bool > -bitmap_desc_hasher::equal (const value_type *d, const compare_type *l) > +bitmap_desc_hasher::equal (const bitmap_descriptor_d *d, const loc *l) > { > return d->file == l->file && d->function == l->function && d->line == l->line; > } > diff --git a/gcc/cfg.c b/gcc/cfg.c > index d96be45..3074500 100644 > --- a/gcc/cfg.c > +++ b/gcc/cfg.c > @@ -1039,21 +1039,22 @@ struct htab_bb_copy_original_entry > > struct bb_copy_hasher : typed_noop_remove <htab_bb_copy_original_entry> > { > - typedef htab_bb_copy_original_entry value_type; > - typedef htab_bb_copy_original_entry compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *existing, > - const compare_type * candidate); > + typedef htab_bb_copy_original_entry *value_type; > + typedef htab_bb_copy_original_entry *compare_type; > + static inline hashval_t hash (const htab_bb_copy_original_entry *); > + static inline bool equal (const htab_bb_copy_original_entry *existing, > + const htab_bb_copy_original_entry * candidate); > }; > > inline hashval_t > -bb_copy_hasher::hash (const value_type *data) > +bb_copy_hasher::hash (const htab_bb_copy_original_entry *data) > { > return data->index1; > } > > inline bool > -bb_copy_hasher::equal (const value_type *data, const compare_type *data2) > +bb_copy_hasher::equal (const htab_bb_copy_original_entry *data, > + const htab_bb_copy_original_entry *data2) > { > return data->index1 == data2->index1; > } > diff --git a/gcc/cgraph.h b/gcc/cgraph.h > index cf8c7b6..29f65a8 100644 > --- a/gcc/cgraph.h > +++ b/gcc/cgraph.h > @@ -1872,7 +1872,6 @@ struct asmname_hasher > { > typedef symtab_node *value_type; > typedef const_tree compare_type; > - typedef int store_values_directly; > > static hashval_t hash (symtab_node *n); > static bool equal (symtab_node *n, const_tree t); > diff --git a/gcc/config/arm/arm.c b/gcc/config/arm/arm.c > index 0466399..6826c78 100644 > --- a/gcc/config/arm/arm.c > +++ b/gcc/config/arm/arm.c > @@ -4897,21 +4897,21 @@ arm_function_value(const_tree type, const_tree func, > > struct libcall_hasher : typed_noop_remove <rtx_def> > { > - typedef rtx_def value_type; > - typedef rtx_def compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > - static inline void remove (value_type *); > + typedef const rtx_def *value_type; > + typedef const rtx_def *compare_type; > + static inline hashval_t hash (const rtx_def *); > + static inline bool equal (const rtx_def *, const rtx_def *); > + static inline void remove (rtx_def *); > }; > > inline bool > -libcall_hasher::equal (const value_type *p1, const compare_type *p2) > +libcall_hasher::equal (const rtx_def *p1, const rtx_def *p2) > { > return rtx_equal_p (p1, p2); > } > > inline hashval_t > -libcall_hasher::hash (const value_type *p1) > +libcall_hasher::hash (const rtx_def *p1) > { > return hash_rtx (p1, VOIDmode, NULL, NULL, FALSE); > } > diff --git a/gcc/config/i386/winnt.c b/gcc/config/i386/winnt.c > index 14fd253..f61412f 100644 > --- a/gcc/config/i386/winnt.c > +++ b/gcc/config/i386/winnt.c > @@ -738,15 +738,15 @@ i386_pe_record_stub (const char *name) > > struct wrapped_symbol_hasher : typed_noop_remove <char> > { > - typedef char value_type; > - typedef char compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > - static inline void remove (value_type *); > + typedef char *value_type; > + typedef char *compare_type; > + static inline hashval_t hash (const char *); > + static inline bool equal (const char *, const char *); > + static inline void remove (char *); > }; > > inline hashval_t > -wrapped_symbol_hasher::hash (const value_type *v) > +wrapped_symbol_hasher::hash (const char *v) > { > return htab_hash_string (v); > } > @@ -754,7 +754,7 @@ wrapped_symbol_hasher::hash (const value_type *v) > /* Hash table equality helper function. */ > > inline bool > -wrapped_symbol_hasher::equal (const value_type *x, const compare_type *y) > +wrapped_symbol_hasher::equal (const char *x, const char *y) > { > return !strcmp (x, y); > } > diff --git a/gcc/config/ia64/ia64.c b/gcc/config/ia64/ia64.c > index 5132d2f..40e6ebe 100644 > --- a/gcc/config/ia64/ia64.c > +++ b/gcc/config/ia64/ia64.c > @@ -8609,16 +8609,16 @@ finish_bundle_states (void) > > struct bundle_state_hasher : typed_noop_remove <bundle_state> > { > - typedef bundle_state value_type; > - typedef bundle_state compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef bundle_state *value_type; > + typedef bundle_state *compare_type; > + static inline hashval_t hash (const bundle_state *); > + static inline bool equal (const bundle_state *, const bundle_state *); > }; > > /* The function returns hash of BUNDLE_STATE. */ > > inline hashval_t > -bundle_state_hasher::hash (const value_type *state) > +bundle_state_hasher::hash (const bundle_state *state) > { > unsigned result, i; > > @@ -8631,8 +8631,8 @@ bundle_state_hasher::hash (const value_type *state) > /* The function returns nonzero if the bundle state keys are equal. */ > > inline bool > -bundle_state_hasher::equal (const value_type *state1, > - const compare_type *state2) > +bundle_state_hasher::equal (const bundle_state *state1, > + const bundle_state *state2) > { > return (state1->insn_num == state2->insn_num > && memcmp (state1->dfa_state, state2->dfa_state, > diff --git a/gcc/config/mips/mips.c b/gcc/config/mips/mips.c > index 1733457..bf69850 100644 > --- a/gcc/config/mips/mips.c > +++ b/gcc/config/mips/mips.c > @@ -16381,23 +16381,23 @@ mips_hash_base (rtx base) > > struct mips_lo_sum_offset_hasher : typed_free_remove <mips_lo_sum_offset> > { > - typedef mips_lo_sum_offset value_type; > - typedef rtx_def compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef mips_lo_sum_offset *value_type; > + typedef rtx_def *compare_type; > + static inline hashval_t hash (const mips_lo_sum_offset *); > + static inline bool equal (const mips_lo_sum_offset *, const rtx_def *); > }; > > /* Hash-table callbacks for mips_lo_sum_offsets. */ > > inline hashval_t > -mips_lo_sum_offset_hasher::hash (const value_type *entry) > +mips_lo_sum_offset_hasher::hash (const mips_lo_sum_offset *entry) > { > return mips_hash_base (entry->base); > } > > inline bool > -mips_lo_sum_offset_hasher::equal (const value_type *entry, > - const compare_type *value) > +mips_lo_sum_offset_hasher::equal (const mips_lo_sum_offset *entry, > + const rtx_def *value) > { > return rtx_equal_p (entry->base, value); > } > diff --git a/gcc/config/sol2.c b/gcc/config/sol2.c > index d256776..d87c7b4 100644 > --- a/gcc/config/sol2.c > +++ b/gcc/config/sol2.c > @@ -183,22 +183,22 @@ typedef struct comdat_entry > > struct comdat_entry_hasher : typed_noop_remove <comdat_entry> > { > - typedef comdat_entry value_type; > - typedef comdat_entry compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > - static inline void remove (value_type *); > + typedef comdat_entry *value_type; > + typedef comdat_entry *compare_type; > + static inline hashval_t hash (const comdat_entry *); > + static inline bool equal (const comdat_entry *, const comdat_entry *); > + static inline void remove (comdat_entry *); > }; > > inline hashval_t > -comdat_entry_hasher::hash (const value_type *entry) > +comdat_entry_hasher::hash (const comdat_entry *entry) > { > return htab_hash_string (entry->sig); > } > > inline bool > -comdat_entry_hasher::equal (const value_type *entry1, > - const compare_type *entry2) > +comdat_entry_hasher::equal (const comdat_entry *entry1, > + const comdat_entry *entry2) > { > return strcmp (entry1->sig, entry2->sig) == 0; > } > diff --git a/gcc/coverage.c b/gcc/coverage.c > index 661e441..e1d81ff 100644 > --- a/gcc/coverage.c > +++ b/gcc/coverage.c > @@ -114,11 +114,11 @@ typedef struct counts_entry > struct gcov_ctr_summary summary; > > /* hash_table support. */ > - typedef counts_entry value_type; > - typedef counts_entry compare_type; > - static inline hashval_t hash (const value_type *); > - static int equal (const value_type *, const compare_type *); > - static void remove (value_type *); > + typedef counts_entry *value_type; > + typedef counts_entry *compare_type; > + static inline hashval_t hash (const counts_entry *); > + static int equal (const counts_entry *, const counts_entry *); > + static void remove (counts_entry *); > } counts_entry_t; > > static GTY(()) struct coverage_data *functions_head = 0; > @@ -197,20 +197,19 @@ get_gcov_unsigned_t (void) > } > > inline hashval_t > -counts_entry::hash (const value_type *entry) > +counts_entry::hash (const counts_entry *entry) > { > return entry->ident * GCOV_COUNTERS + entry->ctr; > } > > inline int > -counts_entry::equal (const value_type *entry1, > - const compare_type *entry2) > +counts_entry::equal (const counts_entry *entry1, const counts_entry *entry2) > { > return entry1->ident == entry2->ident && entry1->ctr == entry2->ctr; > } > > inline void > -counts_entry::remove (value_type *entry) > +counts_entry::remove (counts_entry *entry) > { > free (entry->counts); > free (entry); > diff --git a/gcc/cselib.c b/gcc/cselib.c > index d6ccbfb..30845ed 100644 > --- a/gcc/cselib.c > +++ b/gcc/cselib.c > @@ -102,8 +102,8 @@ static rtx cselib_expand_value_rtx_1 (rtx, struct expand_value_data *, int); > > struct cselib_hasher : typed_noop_remove <cselib_val> > { > - typedef cselib_val value_type; > - struct compare_type { > + typedef cselib_val *value_type; > + struct key { > /* The rtx value and its mode (needed separately for constant > integers). */ > machine_mode mode; > @@ -111,8 +111,9 @@ struct cselib_hasher : typed_noop_remove <cselib_val> > /* The mode of the contaning MEM, if any, otherwise VOIDmode. */ > machine_mode memmode; > }; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef key *compare_type; > + static inline hashval_t hash (const cselib_val *); > + static inline bool equal (const cselib_val *, const key *); > }; > > /* The hash function for our hash table. The value is always computed with > @@ -120,7 +121,7 @@ struct cselib_hasher : typed_noop_remove <cselib_val> > hash value from a cselib_val structure. */ > > inline hashval_t > -cselib_hasher::hash (const value_type *v) > +cselib_hasher::hash (const cselib_val *v) > { > return v->hash; > } > @@ -131,7 +132,7 @@ cselib_hasher::hash (const value_type *v) > CONST of an appropriate mode. */ > > inline bool > -cselib_hasher::equal (const value_type *v, const compare_type *x_arg) > +cselib_hasher::equal (const cselib_val *v, const key *x_arg) > { > struct elt_loc_list *l; > rtx x = x_arg->x; > @@ -507,7 +508,7 @@ preserve_constants_and_equivs (cselib_val **x, void *info ATTRIBUTE_UNUSED) > > if (invariant_or_equiv_p (v)) > { > - cselib_hasher::compare_type lookup = { > + cselib_hasher::key lookup = { > GET_MODE (v->val_rtx), v->val_rtx, VOIDmode > }; > cselib_val **slot > @@ -592,7 +593,7 @@ cselib_find_slot (machine_mode mode, rtx x, hashval_t hash, > enum insert_option insert, machine_mode memmode) > { > cselib_val **slot = NULL; > - cselib_hasher::compare_type lookup = { mode, x, memmode }; > + cselib_hasher::key lookup = { mode, x, memmode }; > if (cselib_preserve_constants) > slot = cselib_preserved_hash_table->find_slot_with_hash (&lookup, hash, > NO_INSERT); > diff --git a/gcc/dse.c b/gcc/dse.c > index 2bb20d7..603cdbd 100644 > --- a/gcc/dse.c > +++ b/gcc/dse.c > @@ -667,21 +667,21 @@ clear_alias_set_lookup (alias_set_type alias_set) > > struct invariant_group_base_hasher : typed_noop_remove <group_info> > { > - typedef group_info value_type; > - typedef group_info compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef group_info *value_type; > + typedef group_info *compare_type; > + static inline hashval_t hash (const group_info *); > + static inline bool equal (const group_info *, const group_info *); > }; > > inline bool > -invariant_group_base_hasher::equal (const value_type *gi1, > - const compare_type *gi2) > +invariant_group_base_hasher::equal (const group_info *gi1, > + const group_info *gi2) > { > return rtx_equal_p (gi1->rtx_base, gi2->rtx_base); > } > > inline hashval_t > -invariant_group_base_hasher::hash (const value_type *gi) > +invariant_group_base_hasher::hash (const group_info *gi) > { > int do_not_record; > return hash_rtx (gi->rtx_base, Pmode, &do_not_record, NULL, false); > diff --git a/gcc/dwarf2cfi.c b/gcc/dwarf2cfi.c > index ec2acc9..2469c25 100644 > --- a/gcc/dwarf2cfi.c > +++ b/gcc/dwarf2cfi.c > @@ -182,20 +182,20 @@ typedef dw_trace_info *dw_trace_info_ref; > > struct trace_info_hasher : typed_noop_remove <dw_trace_info> > { > - typedef dw_trace_info value_type; > - typedef dw_trace_info compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef dw_trace_info *value_type; > + typedef dw_trace_info *compare_type; > + static inline hashval_t hash (const dw_trace_info *); > + static inline bool equal (const dw_trace_info *, const dw_trace_info *); > }; > > inline hashval_t > -trace_info_hasher::hash (const value_type *ti) > +trace_info_hasher::hash (const dw_trace_info *ti) > { > return INSN_UID (ti->head); > } > > inline bool > -trace_info_hasher::equal (const value_type *a, const compare_type *b) > +trace_info_hasher::equal (const dw_trace_info *a, const dw_trace_info *b) > { > return a->head == b->head; > } > diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c > index 6c8e51f..2c33fd5 100644 > --- a/gcc/dwarf2out.c > +++ b/gcc/dwarf2out.c > @@ -6865,28 +6865,28 @@ struct cu_hash_table_entry > > struct cu_hash_table_entry_hasher > { > - typedef cu_hash_table_entry value_type; > - typedef die_struct compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > - static inline void remove (value_type *); > + typedef cu_hash_table_entry *value_type; > + typedef die_struct *compare_type; > + static inline hashval_t hash (const cu_hash_table_entry *); > + static inline bool equal (const cu_hash_table_entry *, const die_struct *); > + static inline void remove (cu_hash_table_entry *); > }; > > inline hashval_t > -cu_hash_table_entry_hasher::hash (const value_type *entry) > +cu_hash_table_entry_hasher::hash (const cu_hash_table_entry *entry) > { > return htab_hash_string (entry->cu->die_id.die_symbol); > } > > inline bool > -cu_hash_table_entry_hasher::equal (const value_type *entry1, > - const compare_type *entry2) > +cu_hash_table_entry_hasher::equal (const cu_hash_table_entry *entry1, > + const die_struct *entry2) > { > return !strcmp (entry1->cu->die_id.die_symbol, entry2->die_id.die_symbol); > } > > inline void > -cu_hash_table_entry_hasher::remove (value_type *entry) > +cu_hash_table_entry_hasher::remove (cu_hash_table_entry *entry) > { > struct cu_hash_table_entry *next; > > @@ -7202,21 +7202,21 @@ struct decl_table_entry > > struct decl_table_entry_hasher : typed_free_remove <decl_table_entry> > { > - typedef decl_table_entry value_type; > - typedef die_struct compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef decl_table_entry *value_type; > + typedef die_struct *compare_type; > + static inline hashval_t hash (const decl_table_entry *); > + static inline bool equal (const decl_table_entry *, const die_struct *); > }; > > inline hashval_t > -decl_table_entry_hasher::hash (const value_type *entry) > +decl_table_entry_hasher::hash (const decl_table_entry *entry) > { > return htab_hash_pointer (entry->orig); > } > > inline bool > -decl_table_entry_hasher::equal (const value_type *entry1, > - const compare_type *entry2) > +decl_table_entry_hasher::equal (const decl_table_entry *entry1, > + const die_struct *entry2) > { > return entry1->orig == entry2; > } > @@ -7744,14 +7744,14 @@ struct external_ref > > struct external_ref_hasher : typed_free_remove <external_ref> > { > - typedef external_ref value_type; > - typedef external_ref compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef external_ref *value_type; > + typedef external_ref *compare_type; > + static inline hashval_t hash (const external_ref *); > + static inline bool equal (const external_ref *, const external_ref *); > }; > > inline hashval_t > -external_ref_hasher::hash (const value_type *r) > +external_ref_hasher::hash (const external_ref *r) > { > dw_die_ref die = r->type; > hashval_t h = 0; > @@ -7772,7 +7772,7 @@ external_ref_hasher::hash (const value_type *r) > } > > inline bool > -external_ref_hasher::equal (const value_type *r1, const compare_type *r2) > +external_ref_hasher::equal (const external_ref *r1, const external_ref *r2) > { > return r1->type == r2->type; > } > @@ -22224,21 +22224,21 @@ dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED, > > struct macinfo_entry_hasher : typed_noop_remove <macinfo_entry> > { > - typedef macinfo_entry value_type; > - typedef macinfo_entry compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef macinfo_entry *value_type; > + typedef macinfo_entry *compare_type; > + static inline hashval_t hash (const macinfo_entry *); > + static inline bool equal (const macinfo_entry *, const macinfo_entry *); > }; > > inline hashval_t > -macinfo_entry_hasher::hash (const value_type *entry) > +macinfo_entry_hasher::hash (const macinfo_entry *entry) > { > return htab_hash_string (entry->info); > } > > inline bool > -macinfo_entry_hasher::equal (const value_type *entry1, > - const compare_type *entry2) > +macinfo_entry_hasher::equal (const macinfo_entry *entry1, > + const macinfo_entry *entry2) > { > return !strcmp (entry1->info, entry2->info); > } > @@ -23302,14 +23302,14 @@ file_table_relative_p (dwarf_file_data **slot, bool *p) > > struct comdat_type_hasher : typed_noop_remove <comdat_type_node> > { > - typedef comdat_type_node value_type; > - typedef comdat_type_node compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef comdat_type_node *value_type; > + typedef comdat_type_node *compare_type; > + static inline hashval_t hash (const comdat_type_node *); > + static inline bool equal (const comdat_type_node *, const comdat_type_node *); > }; > > inline hashval_t > -comdat_type_hasher::hash (const value_type *type_node) > +comdat_type_hasher::hash (const comdat_type_node *type_node) > { > hashval_t h; > memcpy (&h, type_node->signature, sizeof (h)); > @@ -23317,8 +23317,8 @@ comdat_type_hasher::hash (const value_type *type_node) > } > > inline bool > -comdat_type_hasher::equal (const value_type *type_node_1, > - const compare_type *type_node_2) > +comdat_type_hasher::equal (const comdat_type_node *type_node_1, > + const comdat_type_node *type_node_2) > { > return (! memcmp (type_node_1->signature, type_node_2->signature, > DWARF_TYPE_SIGNATURE_SIZE)); > @@ -24405,16 +24405,17 @@ compare_locs (dw_loc_descr_ref x, dw_loc_descr_ref y) > > struct loc_list_hasher : typed_noop_remove <dw_loc_list_struct> > { > - typedef dw_loc_list_struct value_type; > - typedef dw_loc_list_struct compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef dw_loc_list_struct *value_type; > + typedef dw_loc_list_struct *compare_type; > + static inline hashval_t hash (const dw_loc_list_struct *); > + static inline bool equal (const dw_loc_list_struct *, > + const dw_loc_list_struct *); > }; > > /* Return precomputed hash of location list X. */ > > inline hashval_t > -loc_list_hasher::hash (const value_type *x) > +loc_list_hasher::hash (const dw_loc_list_struct *x) > { > return x->hash; > } > @@ -24422,7 +24423,8 @@ loc_list_hasher::hash (const value_type *x) > /* Return true if location lists A and B are the same. */ > > inline bool > -loc_list_hasher::equal (const value_type *a, const compare_type *b) > +loc_list_hasher::equal (const dw_loc_list_struct *a, > + const dw_loc_list_struct *b) > { > if (a == b) > return 1; > diff --git a/gcc/except.c b/gcc/except.c > index 833ec21..f85e55a 100644 > --- a/gcc/except.c > +++ b/gcc/except.c > @@ -227,20 +227,21 @@ struct action_record > > struct action_record_hasher : typed_free_remove <action_record> > { > - typedef action_record value_type; > - typedef action_record compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef action_record *value_type; > + typedef action_record *compare_type; > + static inline hashval_t hash (const action_record *); > + static inline bool equal (const action_record *, const action_record *); > }; > > inline hashval_t > -action_record_hasher::hash (const value_type *entry) > +action_record_hasher::hash (const action_record *entry) > { > return entry->next * 1009 + entry->filter; > } > > inline bool > -action_record_hasher::equal (const value_type *entry, const compare_type *data) > +action_record_hasher::equal (const action_record *entry, > + const action_record *data) > { > return entry->filter == data->filter && entry->next == data->next; > } > @@ -742,23 +743,23 @@ struct ttypes_filter { > > struct ttypes_filter_hasher : typed_free_remove <ttypes_filter> > { > - typedef ttypes_filter value_type; > - typedef tree_node compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef ttypes_filter *value_type; > + typedef tree_node *compare_type; > + static inline hashval_t hash (const ttypes_filter *); > + static inline bool equal (const ttypes_filter *, const tree_node *); > }; > > /* Compare ENTRY (a ttypes_filter entry in the hash table) with DATA > (a tree) for a @TTypes type node we are thinking about adding. */ > > inline bool > -ttypes_filter_hasher::equal (const value_type *entry, const compare_type *data) > +ttypes_filter_hasher::equal (const ttypes_filter *entry, const tree_node *data) > { > return entry->t == data; > } > > inline hashval_t > -ttypes_filter_hasher::hash (const value_type *entry) > +ttypes_filter_hasher::hash (const ttypes_filter *entry) > { > return TREE_HASH (entry->t); > } > @@ -770,10 +771,10 @@ typedef hash_table<ttypes_filter_hasher> ttypes_hash_type; > > struct ehspec_hasher : typed_free_remove <ttypes_filter> > { > - typedef ttypes_filter value_type; > - typedef ttypes_filter compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef ttypes_filter *value_type; > + typedef ttypes_filter *compare_type; > + static inline hashval_t hash (const ttypes_filter *); > + static inline bool equal (const ttypes_filter *, const ttypes_filter *); > }; > > /* Compare ENTRY with DATA (both struct ttypes_filter) for a @TTypes > @@ -782,7 +783,7 @@ struct ehspec_hasher : typed_free_remove <ttypes_filter> > should put these in some canonical order. */ > > inline bool > -ehspec_hasher::equal (const value_type *entry, const compare_type *data) > +ehspec_hasher::equal (const ttypes_filter *entry, const ttypes_filter *data) > { > return type_list_equal (entry->t, data->t); > } > @@ -790,7 +791,7 @@ ehspec_hasher::equal (const value_type *entry, const compare_type *data) > /* Hash function for exception specification lists. */ > > inline hashval_t > -ehspec_hasher::hash (const value_type *entry) > +ehspec_hasher::hash (const ttypes_filter *entry) > { > hashval_t h = 0; > tree list; > diff --git a/gcc/gcse.c b/gcc/gcse.c > index 37aac6a..4be3f36 100644 > --- a/gcc/gcse.c > +++ b/gcc/gcse.c > @@ -388,15 +388,15 @@ static struct ls_expr * pre_ldst_mems = NULL; > > struct pre_ldst_expr_hasher : typed_noop_remove <ls_expr> > { > - typedef ls_expr value_type; > + typedef ls_expr *value_type; > typedef value_type compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + static inline hashval_t hash (const ls_expr *); > + static inline bool equal (const ls_expr *, const ls_expr *); > }; > > /* Hashtable helpers. */ > inline hashval_t > -pre_ldst_expr_hasher::hash (const value_type *x) > +pre_ldst_expr_hasher::hash (const ls_expr *x) > { > int do_not_record_p = 0; > return > @@ -406,8 +406,8 @@ pre_ldst_expr_hasher::hash (const value_type *x) > static int expr_equiv_p (const_rtx, const_rtx); > > inline bool > -pre_ldst_expr_hasher::equal (const value_type *ptr1, > - const compare_type *ptr2) > +pre_ldst_expr_hasher::equal (const ls_expr *ptr1, > + const ls_expr *ptr2) > { > return expr_equiv_p (ptr1->pattern, ptr2->pattern); > } > diff --git a/gcc/genmatch.c b/gcc/genmatch.c > index 560a371..fbd12a5 100644 > --- a/gcc/genmatch.c > +++ b/gcc/genmatch.c > @@ -190,21 +190,21 @@ struct id_base : typed_noop_remove<id_base> > const char *id; > > /* hash_table support. */ > - typedef id_base value_type; > - typedef id_base compare_type; > - static inline hashval_t hash (const value_type *); > - static inline int equal (const value_type *, const compare_type *); > + typedef id_base *value_type; > + typedef id_base *compare_type; > + static inline hashval_t hash (const id_base *); > + static inline int equal (const id_base *, const id_base *); > }; > > inline hashval_t > -id_base::hash (const value_type *op) > +id_base::hash (const id_base *op) > { > return op->hashval; > } > > inline int > -id_base::equal (const value_type *op1, > - const compare_type *op2) > +id_base::equal (const id_base *op1, > + const id_base *op2) > { > return (op1->hashval == op2->hashval > && strcmp (op1->id, op2->id) == 0); > diff --git a/gcc/ggc-common.c b/gcc/ggc-common.c > index 03fbe7d..eff326a 100644 > --- a/gcc/ggc-common.c > +++ b/gcc/ggc-common.c > @@ -242,20 +242,20 @@ struct ptr_data > > struct saving_hasher : typed_free_remove <ptr_data> > { > - typedef ptr_data value_type; > - typedef void compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef ptr_data *value_type; > + typedef void *compare_type; > + static inline hashval_t hash (const ptr_data *); > + static inline bool equal (const ptr_data *, const void *); > }; > > inline hashval_t > -saving_hasher::hash (const value_type *p) > +saving_hasher::hash (const ptr_data *p) > { > return POINTER_HASH (p->obj); > } > > inline bool > -saving_hasher::equal (const value_type *p1, const compare_type *p2) > +saving_hasher::equal (const ptr_data *p1, const void *p2) > { > return p1->obj == p2; > } > @@ -847,20 +847,22 @@ struct ggc_loc_descriptor > > struct ggc_loc_desc_hasher : typed_noop_remove <ggc_loc_descriptor> > { > - typedef ggc_loc_descriptor value_type; > - typedef ggc_loc_descriptor compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef ggc_loc_descriptor *value_type; > + typedef ggc_loc_descriptor *compare_type; > + static inline hashval_t hash (const ggc_loc_descriptor *); > + static inline bool equal (const ggc_loc_descriptor *, > + const ggc_loc_descriptor *); > }; > > inline hashval_t > -ggc_loc_desc_hasher::hash (const value_type *d) > +ggc_loc_desc_hasher::hash (const ggc_loc_descriptor *d) > { > return htab_hash_pointer (d->function) | d->line; > } > > inline bool > -ggc_loc_desc_hasher::equal (const value_type *d, const compare_type *d2) > +ggc_loc_desc_hasher::equal (const ggc_loc_descriptor *d, > + const ggc_loc_descriptor *d2) > { > return (d->file == d2->file && d->line == d2->line > && d->function == d2->function); > @@ -880,20 +882,20 @@ struct ggc_ptr_hash_entry > > struct ptr_hash_hasher : typed_noop_remove <ggc_ptr_hash_entry> > { > - typedef ggc_ptr_hash_entry value_type; > - typedef void compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef ggc_ptr_hash_entry *value_type; > + typedef void *compare_type; > + static inline hashval_t hash (const ggc_ptr_hash_entry *); > + static inline bool equal (const ggc_ptr_hash_entry *, const void *); > }; > > inline hashval_t > -ptr_hash_hasher::hash (const value_type *d) > +ptr_hash_hasher::hash (const ggc_ptr_hash_entry *d) > { > return htab_hash_pointer (d->ptr); > } > > inline bool > -ptr_hash_hasher::equal (const value_type *p, const compare_type *p2) > +ptr_hash_hasher::equal (const ggc_ptr_hash_entry *p, const void *p2) > { > return (p->ptr == p2); > } > diff --git a/gcc/gimple-ssa-strength-reduction.c b/gcc/gimple-ssa-strength-reduction.c > index 5b84bbe..afd3215 100644 > --- a/gcc/gimple-ssa-strength-reduction.c > +++ b/gcc/gimple-ssa-strength-reduction.c > @@ -438,21 +438,21 @@ lookup_cand (cand_idx idx) > > struct cand_chain_hasher : typed_noop_remove <cand_chain> > { > - typedef cand_chain value_type; > - typedef cand_chain compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef cand_chain *value_type; > + typedef cand_chain *compare_type; > + static inline hashval_t hash (const cand_chain *); > + static inline bool equal (const cand_chain *, const cand_chain *); > }; > > inline hashval_t > -cand_chain_hasher::hash (const value_type *p) > +cand_chain_hasher::hash (const cand_chain *p) > { > tree base_expr = p->base_expr; > return iterative_hash_expr (base_expr, 0); > } > > inline bool > -cand_chain_hasher::equal (const value_type *chain1, const compare_type *chain2) > +cand_chain_hasher::equal (const cand_chain *chain1, const cand_chain *chain2) > { > return operand_equal_p (chain1->base_expr, chain2->base_expr, 0); > } > diff --git a/gcc/gimplify.c b/gcc/gimplify.c > index ff0a225..a52455d 100644 > --- a/gcc/gimplify.c > +++ b/gcc/gimplify.c > @@ -136,10 +136,10 @@ enum omp_region_type > > struct gimplify_hasher : typed_free_remove <elt_t> > { > - typedef elt_t value_type; > - typedef elt_t compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef elt_t *value_type; > + typedef elt_t *compare_type; > + static inline hashval_t hash (const elt_t *); > + static inline bool equal (const elt_t *, const elt_t *); > }; > > struct gimplify_ctx > @@ -9384,14 +9384,14 @@ gimplify_assign (tree dst, tree src, gimple_seq *seq_p) > } > > inline hashval_t > -gimplify_hasher::hash (const value_type *p) > +gimplify_hasher::hash (const elt_t *p) > { > tree t = p->val; > return iterative_hash_expr (t, 0); > } > > inline bool > -gimplify_hasher::equal (const value_type *p1, const compare_type *p2) > +gimplify_hasher::equal (const elt_t *p1, const elt_t *p2) > { > tree t1 = p1->val; > tree t2 = p2->val; > diff --git a/gcc/haifa-sched.c b/gcc/haifa-sched.c > index ad2450b..96c038f 100644 > --- a/gcc/haifa-sched.c > +++ b/gcc/haifa-sched.c > @@ -621,16 +621,16 @@ struct delay_pair > > struct delay_i1_hasher : typed_noop_remove <delay_pair> > { > - typedef delay_pair value_type; > - typedef void compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef delay_pair *value_type; > + typedef void *compare_type; > + static inline hashval_t hash (const delay_pair *); > + static inline bool equal (const delay_pair *, const void *); > }; > > /* Returns a hash value for X, based on hashing just I1. */ > > inline hashval_t > -delay_i1_hasher::hash (const value_type *x) > +delay_i1_hasher::hash (const delay_pair *x) > { > return htab_hash_pointer (x->i1); > } > @@ -638,23 +638,23 @@ delay_i1_hasher::hash (const value_type *x) > /* Return true if I1 of pair X is the same as that of pair Y. */ > > inline bool > -delay_i1_hasher::equal (const value_type *x, const compare_type *y) > +delay_i1_hasher::equal (const delay_pair *x, const void *y) > { > return x->i1 == y; > } > > struct delay_i2_hasher : typed_free_remove <delay_pair> > { > - typedef delay_pair value_type; > - typedef void compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef delay_pair *value_type; > + typedef void *compare_type; > + static inline hashval_t hash (const delay_pair *); > + static inline bool equal (const delay_pair *, const void *); > }; > > /* Returns a hash value for X, based on hashing just I2. */ > > inline hashval_t > -delay_i2_hasher::hash (const value_type *x) > +delay_i2_hasher::hash (const delay_pair *x) > { > return htab_hash_pointer (x->i2); > } > @@ -662,7 +662,7 @@ delay_i2_hasher::hash (const value_type *x) > /* Return true if I2 of pair X is the same as that of pair Y. */ > > inline bool > -delay_i2_hasher::equal (const value_type *x, const compare_type *y) > +delay_i2_hasher::equal (const delay_pair *x, const void *y) > { > return x->i2 == y; > } > diff --git a/gcc/hard-reg-set.h b/gcc/hard-reg-set.h > index d1a6e51..89971d7 100644 > --- a/gcc/hard-reg-set.h > +++ b/gcc/hard-reg-set.h > @@ -615,7 +615,17 @@ hard_reg_set_iter_next (hard_reg_set_iterator *iter, unsigned *regno) > > extern char global_regs[FIRST_PSEUDO_REGISTER]; > > -struct simplifiable_subregs_hasher; > +struct simplifiable_subreg; > +struct subreg_shape; > + > +struct simplifiable_subregs_hasher : typed_noop_remove <simplifiable_subreg> > +{ > + typedef simplifiable_subreg *value_type; > + typedef const subreg_shape *compare_type; > + > + static inline hashval_t hash (const simplifiable_subreg *); > + static inline bool equal (const simplifiable_subreg *, const subreg_shape *); > +}; > > struct target_hard_regs { > void finalize (); > diff --git a/gcc/hash-map.h b/gcc/hash-map.h > index e1dea91..4cca702 100644 > --- a/gcc/hash-map.h > +++ b/gcc/hash-map.h > @@ -114,7 +114,6 @@ class GTY((user)) hash_map > > typedef hash_entry value_type; > typedef Key compare_type; > - typedef int store_values_directly; > > static hashval_t hash (const hash_entry &e) > { > diff --git a/gcc/hash-set.h b/gcc/hash-set.h > index c1e8872..9065451 100644 > --- a/gcc/hash-set.h > +++ b/gcc/hash-set.h > @@ -112,7 +112,6 @@ class hash_set > > typedef hash_entry value_type; > typedef Key compare_type; > - typedef int store_values_directly; > > static hashval_t hash (const hash_entry &e) > { > diff --git a/gcc/hash-table.h b/gcc/hash-table.h > index 447eaff..f6375d1 100644 > --- a/gcc/hash-table.h > +++ b/gcc/hash-table.h > @@ -278,7 +278,6 @@ struct pointer_hash : typed_noop_remove <Type> > { > typedef Type *value_type; > typedef Type *compare_type; > - typedef int store_values_directly; > > static inline hashval_t hash (const value_type &); > > @@ -310,7 +309,6 @@ struct ggc_hasher > { > typedef T value_type; > typedef T compare_type; > - typedef int store_values_directly; > > static void remove (T) {} > > @@ -342,7 +340,6 @@ struct ggc_cache_hasher > { > typedef T value_type; > typedef T compare_type; > - typedef int store_values_directly; > > static void remove (T &) {} > > @@ -438,26 +435,6 @@ hash_table_mod2 (hashval_t hash, unsigned int index) > return 1 + mul_mod (hash, p->prime - 2, p->inv_m2, p->shift); > } > > -/* The below is some template meta programming to decide if we should use the > - hash table partial specialization that directly stores value_type instead of > - pointers to value_type. If the Descriptor type defines the type > - Descriptor::store_values_directly then values are stored directly otherwise > - pointers to them are stored. */ > -template<typename T> struct notype { typedef void type; }; > - > -template<typename T, typename = void> > -struct storage_tester > -{ > - static const bool value = false; > -}; > - > -template<typename T> > -struct storage_tester<T, typename notype<typename > - T::store_values_directly>::type> > -{ > - static const bool value = true; > -}; > - > template<typename Traits> > struct has_is_deleted > { > @@ -576,9 +553,7 @@ struct mark_empty_helper<Type *, Traits, false> > > /* User-facing hash table type. > > - The table stores elements of type Descriptor::value_type, or pointers to > - objects of type value_type if the descriptor does not define the type > - store_values_directly. > + The table stores elements of type Descriptor::value_type. > > It hashes values with the hash member function. > The table currently works with relatively weak hash functions. > @@ -601,518 +576,9 @@ struct mark_empty_helper<Type *, Traits, false> > > */ > template <typename Descriptor, > - template<typename Type> class Allocator= xcallocator, > - bool Storage = storage_tester<Descriptor>::value> > + template<typename Type> class Allocator = xcallocator> > class hash_table > { > -}; > - > -template <typename Descriptor, > - template<typename Type> class Allocator> > -class hash_table<Descriptor, Allocator, false> > -{ > - typedef typename Descriptor::value_type value_type; > - typedef typename Descriptor::compare_type compare_type; > - > -public: > - hash_table (size_t CXX_MEM_STAT_INFO); > - ~hash_table (); > - > - /* Current size (in entries) of the hash table. */ > - size_t size () const { return m_size; } > - > - /* Return the current number of elements in this hash table. */ > - size_t elements () const { return m_n_elements - m_n_deleted; } > - > - /* Return the current number of elements in this hash table. */ > - size_t elements_with_deleted () const { return m_n_elements; } > - > - /* This function clears all entries in the given hash table. */ > - void empty (); > - > - /* This function clears a specified SLOT in a hash table. It is > - useful when you've already done the lookup and don't want to do it > - again. */ > - > - void clear_slot (value_type **); > - > - /* This function searches for a hash table entry equal to the given > - COMPARABLE element starting with the given HASH value. It cannot > - be used to insert or delete an element. */ > - value_type *find_with_hash (const compare_type *, hashval_t); > - > -/* Like find_slot_with_hash, but compute the hash value from the element. */ > - value_type *find (const value_type *value) > - { > - return find_with_hash (value, Descriptor::hash (value)); > - } > - > - value_type **find_slot (const value_type *value, insert_option insert) > - { > - return find_slot_with_hash (value, Descriptor::hash (value), insert); > - } > - > - /* This function searches for a hash table slot containing an entry > - equal to the given COMPARABLE element and starting with the given > - HASH. To delete an entry, call this with insert=NO_INSERT, then > - call clear_slot on the slot returned (possibly after doing some > - checks). To insert an entry, call this with insert=INSERT, then > - write the value you want into the returned slot. When inserting an > - entry, NULL may be returned if memory allocation fails. */ > - value_type **find_slot_with_hash (const compare_type *comparable, > - hashval_t hash, enum insert_option insert); > - > - /* This function deletes an element with the given COMPARABLE value > - from hash table starting with the given HASH. If there is no > - matching element in the hash table, this function does nothing. */ > - void remove_elt_with_hash (const compare_type *, hashval_t); > - > -/* Like remove_elt_with_hash, but compute the hash value from the element. */ > - void remove_elt (const value_type *value) > - { > - remove_elt_with_hash (value, Descriptor::hash (value)); > - } > - > - /* This function scans over the entire hash table calling CALLBACK for > - each live entry. If CALLBACK returns false, the iteration stops. > - ARGUMENT is passed as CALLBACK's second argument. */ > - template <typename Argument, > - int (*Callback) (value_type **slot, Argument argument)> > - void traverse_noresize (Argument argument); > - > - /* Like traverse_noresize, but does resize the table when it is too empty > - to improve effectivity of subsequent calls. */ > - template <typename Argument, > - int (*Callback) (value_type **slot, Argument argument)> > - void traverse (Argument argument); > - > - class iterator > - { > - public: > - iterator () : m_slot (NULL), m_limit (NULL) {} > - > - iterator (value_type **slot, value_type **limit) : > - m_slot (slot), m_limit (limit) {} > - > - inline value_type *operator * () { return *m_slot; } > - void slide (); > - inline iterator &operator ++ (); > - bool operator != (const iterator &other) const > - { > - return m_slot != other.m_slot || m_limit != other.m_limit; > - } > - > - private: > - value_type **m_slot; > - value_type **m_limit; > - }; > - > - iterator begin () const > - { > - iterator iter (m_entries, m_entries + m_size); > - iter.slide (); > - return iter; > - } > - > - iterator end () const { return iterator (); } > - > - double collisions () const > - { > - return m_searches ? static_cast <double> (m_collisions) / m_searches : 0; > - } > - > -private: > - > - value_type **find_empty_slot_for_expand (hashval_t); > - void expand (); > - > - /* Table itself. */ > - typename Descriptor::value_type **m_entries; > - > - size_t m_size; > - > - /* Current number of elements including also deleted elements. */ > - size_t m_n_elements; > - > - /* Current number of deleted elements in the table. */ > - size_t m_n_deleted; > - > - /* The following member is used for debugging. Its value is number > - of all calls of `htab_find_slot' for the hash table. */ > - unsigned int m_searches; > - > - /* The following member is used for debugging. Its value is number > - of collisions fixed for time of work with the hash table. */ > - unsigned int m_collisions; > - > - /* Current size (in entries) of the hash table, as an index into the > - table of primes. */ > - unsigned int m_size_prime_index; > -}; > - > -template<typename Descriptor, template<typename Type> class Allocator> > -hash_table<Descriptor, Allocator, false>::hash_table (size_t size > - MEM_STAT_DECL) : > - m_n_elements (0), m_n_deleted (0), m_searches (0), m_collisions (0) > -{ > - 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); > - gcc_assert (m_entries != NULL); > - m_size = size; > - m_size_prime_index = size_prime_index; > -} > - > -template<typename Descriptor, template<typename Type> class Allocator> > -hash_table<Descriptor, Allocator, false>::~hash_table () > -{ > - for (size_t i = m_size - 1; i < m_size; i--) > - if (m_entries[i] != HTAB_EMPTY_ENTRY && m_entries[i] != HTAB_DELETED_ENTRY) > - Descriptor::remove (m_entries[i]); > - > - Allocator <value_type *> ::data_free (m_entries); > -} > - > -/* Similar to find_slot, but without several unwanted side effects: > - - Does not call equal when it finds an existing entry. > - - Does not change the count of elements/searches/collisions in the > - hash table. > - This function also assumes there are no deleted entries in the table. > - HASH is the hash value for the element to be inserted. */ > - > -template<typename Descriptor, template<typename Type> class Allocator> > -typename hash_table<Descriptor, Allocator, false>::value_type ** > -hash_table<Descriptor, Allocator, false> > -::find_empty_slot_for_expand (hashval_t hash) > -{ > - hashval_t index = hash_table_mod1 (hash, m_size_prime_index); > - size_t size = m_size; > - value_type **slot = m_entries + index; > - hashval_t hash2; > - > - if (*slot == HTAB_EMPTY_ENTRY) > - return slot; > - gcc_checking_assert (*slot != HTAB_DELETED_ENTRY); > - > - hash2 = hash_table_mod2 (hash, m_size_prime_index); > - for (;;) > - { > - index += hash2; > - if (index >= size) > - index -= size; > - > - slot = m_entries + index; > - if (*slot == HTAB_EMPTY_ENTRY) > - return slot; > - gcc_checking_assert (*slot != HTAB_DELETED_ENTRY); > - } > -} > - > -/* The following function changes size of memory allocated for the > - entries and repeatedly inserts the table elements. The occupancy > - of the table after the call will be about 50%. Naturally the hash > - table must already exist. Remember also that the place of the > - table entries is changed. If memory allocation fails, this function > - will abort. */ > - > -template<typename Descriptor, template<typename Type> class Allocator> > -void > -hash_table<Descriptor, Allocator, false>::expand () > -{ > - value_type **oentries = m_entries; > - unsigned int oindex = m_size_prime_index; > - size_t osize = size (); > - value_type **olimit = oentries + osize; > - size_t elts = elements (); > - > - /* Resize only when table after removal of unused elements is either > - too full or too empty. */ > - unsigned int nindex; > - size_t nsize; > - if (elts * 2 > osize || (elts * 8 < osize && osize > 32)) > - { > - nindex = hash_table_higher_prime_index (elts * 2); > - nsize = prime_tab[nindex].prime; > - } > - else > - { > - nindex = oindex; > - nsize = osize; > - } > - > - value_type **nentries = Allocator <value_type *> ::data_alloc (nsize); > - gcc_assert (nentries != NULL); > - m_entries = nentries; > - m_size = nsize; > - m_size_prime_index = nindex; > - m_n_elements -= m_n_deleted; > - m_n_deleted = 0; > - > - value_type **p = oentries; > - do > - { > - value_type *x = *p; > - > - if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY) > - { > - value_type **q = find_empty_slot_for_expand (Descriptor::hash (x)); > - > - *q = x; > - } > - > - p++; > - } > - while (p < olimit); > - > - Allocator <value_type *> ::data_free (oentries); > -} > - > -template<typename Descriptor, template<typename Type> class Allocator> > -void > -hash_table<Descriptor, Allocator, false>::empty () > -{ > - size_t size = m_size; > - value_type **entries = m_entries; > - int i; > - > - for (i = size - 1; i >= 0; i--) > - if (entries[i] != HTAB_EMPTY_ENTRY && entries[i] != HTAB_DELETED_ENTRY) > - Descriptor::remove (entries[i]); > - > - /* Instead of clearing megabyte, downsize the table. */ > - if (size > 1024*1024 / sizeof (PTR)) > - { > - 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); > - m_size = nsize; > - m_size_prime_index = nindex; > - } > - else > - memset (entries, 0, size * sizeof (value_type *)); > - m_n_deleted = 0; > - m_n_elements = 0; > -} > - > -/* This function clears a specified SLOT in a hash table. It is > - useful when you've already done the lookup and don't want to do it > - again. */ > - > -template<typename Descriptor, template<typename Type> class Allocator> > -void > -hash_table<Descriptor, Allocator, false>::clear_slot (value_type **slot) > -{ > - gcc_checking_assert (!(slot < m_entries || slot >= m_entries + size () > - || *slot == HTAB_EMPTY_ENTRY > - || *slot == HTAB_DELETED_ENTRY)); > - > - Descriptor::remove (*slot); > - > - *slot = static_cast <value_type *> (HTAB_DELETED_ENTRY); > - m_n_deleted++; > -} > - > -/* This function searches for a hash table entry equal to the given > - COMPARABLE element starting with the given HASH value. It cannot > - be used to insert or delete an element. */ > - > -template<typename Descriptor, template<typename Type> class Allocator> > -typename hash_table<Descriptor, Allocator, false>::value_type * > -hash_table<Descriptor, Allocator, false> > -::find_with_hash (const compare_type *comparable, hashval_t hash) > -{ > - m_searches++; > - size_t size = m_size; > - hashval_t index = hash_table_mod1 (hash, m_size_prime_index); > - > - value_type *entry = m_entries[index]; > - if (entry == HTAB_EMPTY_ENTRY > - || (entry != HTAB_DELETED_ENTRY && Descriptor::equal (entry, comparable))) > - return entry; > - > - hashval_t hash2 = hash_table_mod2 (hash, m_size_prime_index); > - for (;;) > - { > - m_collisions++; > - index += hash2; > - if (index >= size) > - index -= size; > - > - entry = m_entries[index]; > - if (entry == HTAB_EMPTY_ENTRY > - || (entry != HTAB_DELETED_ENTRY > - && Descriptor::equal (entry, comparable))) > - return entry; > - } > -} > - > -/* This function searches for a hash table slot containing an entry > - equal to the given COMPARABLE element and starting with the given > - HASH. To delete an entry, call this with insert=NO_INSERT, then > - call clear_slot on the slot returned (possibly after doing some > - checks). To insert an entry, call this with insert=INSERT, then > - write the value you want into the returned slot. When inserting an > - entry, NULL may be returned if memory allocation fails. */ > - > -template<typename Descriptor, template<typename Type> class Allocator> > -typename hash_table<Descriptor, Allocator, false>::value_type ** > -hash_table<Descriptor, Allocator, false> > -::find_slot_with_hash (const compare_type *comparable, hashval_t hash, > - enum insert_option insert) > -{ > - if (insert == INSERT && m_size * 3 <= m_n_elements * 4) > - expand (); > - > - m_searches++; > - > - value_type **first_deleted_slot = NULL; > - hashval_t index = hash_table_mod1 (hash, m_size_prime_index); > - hashval_t hash2 = hash_table_mod2 (hash, m_size_prime_index); > - value_type *entry = m_entries[index]; > - size_t size = m_size; > - if (entry == HTAB_EMPTY_ENTRY) > - goto empty_entry; > - else if (entry == HTAB_DELETED_ENTRY) > - first_deleted_slot = &m_entries[index]; > - else if (Descriptor::equal (entry, comparable)) > - return &m_entries[index]; > - > - for (;;) > - { > - m_collisions++; > - index += hash2; > - if (index >= size) > - index -= size; > - > - entry = m_entries[index]; > - if (entry == HTAB_EMPTY_ENTRY) > - goto empty_entry; > - else if (entry == HTAB_DELETED_ENTRY) > - { > - if (!first_deleted_slot) > - first_deleted_slot = &m_entries[index]; > - } > - else if (Descriptor::equal (entry, comparable)) > - return &m_entries[index]; > - } > - > - empty_entry: > - if (insert == NO_INSERT) > - return NULL; > - > - if (first_deleted_slot) > - { > - m_n_deleted--; > - *first_deleted_slot = static_cast <value_type *> (HTAB_EMPTY_ENTRY); > - return first_deleted_slot; > - } > - > - m_n_elements++; > - return &m_entries[index]; > -} > - > -/* This function deletes an element with the given COMPARABLE value > - from hash table starting with the given HASH. If there is no > - matching element in the hash table, this function does nothing. */ > - > -template<typename Descriptor, template<typename Type> class Allocator> > -void > -hash_table<Descriptor, Allocator, false> > -::remove_elt_with_hash (const compare_type *comparable, hashval_t hash) > -{ > - value_type **slot = find_slot_with_hash (comparable, hash, NO_INSERT); > - if (*slot == HTAB_EMPTY_ENTRY) > - return; > - > - Descriptor::remove (*slot); > - > - *slot = static_cast <value_type *> (HTAB_DELETED_ENTRY); > - m_n_deleted++; > -} > - > -/* This function scans over the entire hash table calling CALLBACK for > - each live entry. If CALLBACK returns false, the iteration stops. > - ARGUMENT is passed as CALLBACK's second argument. */ > - > -template<typename Descriptor, template<typename Type> class Allocator> > -template<typename Argument, > - int (*Callback) (typename hash_table<Descriptor, Allocator, > - false>::value_type **slot, > - Argument argument)> > -void > -hash_table<Descriptor, Allocator, false>::traverse_noresize (Argument argument) > -{ > - value_type **slot = m_entries; > - value_type **limit = slot + size (); > - > - do > - { > - value_type *x = *slot; > - > - if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY) > - if (! Callback (slot, argument)) > - break; > - } > - while (++slot < limit); > -} > - > -/* Like traverse_noresize, but does resize the table when it is too empty > - to improve effectivity of subsequent calls. */ > - > -template <typename Descriptor, > - template <typename Type> class Allocator> > -template <typename Argument, > - int (*Callback) (typename hash_table<Descriptor, Allocator, > - false>::value_type **slot, > - Argument argument)> > -void > -hash_table<Descriptor, Allocator, false>::traverse (Argument argument) > -{ > - size_t size = m_size; > - if (elements () * 8 < size && size > 32) > - expand (); > - > - traverse_noresize <Argument, Callback> (argument); > -} > - > -/* Slide down the iterator slots until an active entry is found. */ > - > -template<typename Descriptor, template<typename Type> class Allocator> > -void > -hash_table<Descriptor, Allocator, false>::iterator::slide () > -{ > - for ( ; m_slot < m_limit; ++m_slot ) > - { > - value_type *x = *m_slot; > - if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY) > - return; > - } > - m_slot = NULL; > - m_limit = NULL; > -} > - > -/* Bump the iterator. */ > - > -template<typename Descriptor, template<typename Type> class Allocator> > -inline typename hash_table<Descriptor, Allocator, false>::iterator & > -hash_table<Descriptor, Allocator, false>::iterator::operator ++ () > -{ > - ++m_slot; > - slide (); > - return *this; > -} > - > -/* A partial specialization used when values should be stored directly. */ > - > -template <typename Descriptor, > - template<typename Type> class Allocator> > -class hash_table<Descriptor, Allocator, true> > -{ > typedef typename Descriptor::value_type value_type; > typedef typename Descriptor::compare_type compare_type; > > @@ -1296,7 +762,7 @@ private: > }; > > template<typename Descriptor, template<typename Type> class Allocator> > -hash_table<Descriptor, Allocator, true>::hash_table (size_t size, bool ggc > +hash_table<Descriptor, Allocator>::hash_table (size_t size, bool ggc > MEM_STAT_DECL) : > m_n_elements (0), m_n_deleted (0), m_searches (0), m_collisions (0), > m_ggc (ggc) > @@ -1312,7 +778,7 @@ hash_table<Descriptor, Allocator, true>::hash_table (size_t size, bool ggc > } > > template<typename Descriptor, template<typename Type> class Allocator> > -hash_table<Descriptor, Allocator, true>::~hash_table () > +hash_table<Descriptor, Allocator>::~hash_table () > { > for (size_t i = m_size - 1; i < m_size; i--) > if (!is_empty (m_entries[i]) && !is_deleted (m_entries[i])) > @@ -1327,9 +793,8 @@ hash_table<Descriptor, Allocator, true>::~hash_table () > /* This function returns an array of empty hash table elements. */ > > template<typename Descriptor, template<typename Type> class Allocator> > -inline typename hash_table<Descriptor, Allocator, true>::value_type * > -hash_table<Descriptor, Allocator, true>::alloc_entries > - (size_t n MEM_STAT_DECL) const > +inline typename hash_table<Descriptor, Allocator>::value_type * > +hash_table<Descriptor, Allocator>::alloc_entries (size_t n MEM_STAT_DECL) const > { > value_type *nentries; > > @@ -1353,9 +818,8 @@ hash_table<Descriptor, Allocator, true>::alloc_entries > HASH is the hash value for the element to be inserted. */ > > template<typename Descriptor, template<typename Type> class Allocator> > -typename hash_table<Descriptor, Allocator, true>::value_type * > -hash_table<Descriptor, Allocator, true> > -::find_empty_slot_for_expand (hashval_t hash) > +typename hash_table<Descriptor, Allocator>::value_type * > +hash_table<Descriptor, Allocator>::find_empty_slot_for_expand (hashval_t hash) > { > hashval_t index = hash_table_mod1 (hash, m_size_prime_index); > size_t size = m_size; > @@ -1393,7 +857,7 @@ hash_table<Descriptor, Allocator, true> > > template<typename Descriptor, template<typename Type> class Allocator> > void > -hash_table<Descriptor, Allocator, true>::expand () > +hash_table<Descriptor, Allocator>::expand () > { > value_type *oentries = m_entries; > unsigned int oindex = m_size_prime_index; > @@ -1447,7 +911,7 @@ hash_table<Descriptor, Allocator, true>::expand () > > template<typename Descriptor, template<typename Type> class Allocator> > void > -hash_table<Descriptor, Allocator, true>::empty () > +hash_table<Descriptor, Allocator>::empty () > { > size_t size = m_size; > value_type *entries = m_entries; > @@ -1484,7 +948,7 @@ hash_table<Descriptor, Allocator, true>::empty () > > template<typename Descriptor, template<typename Type> class Allocator> > void > -hash_table<Descriptor, Allocator, true>::clear_slot (value_type *slot) > +hash_table<Descriptor, Allocator>::clear_slot (value_type *slot) > { > gcc_checking_assert (!(slot < m_entries || slot >= m_entries + size () > || is_empty (*slot) || is_deleted (*slot))); > @@ -1500,8 +964,8 @@ hash_table<Descriptor, Allocator, true>::clear_slot (value_type *slot) > be used to insert or delete an element. */ > > template<typename Descriptor, template<typename Type> class Allocator> > -typename hash_table<Descriptor, Allocator, true>::value_type & > -hash_table<Descriptor, Allocator, true> > +typename hash_table<Descriptor, Allocator>::value_type & > +hash_table<Descriptor, Allocator> > ::find_with_hash (const compare_type &comparable, hashval_t hash) > { > m_searches++; > @@ -1537,8 +1001,8 @@ hash_table<Descriptor, Allocator, true> > entry, NULL may be returned if memory allocation fails. */ > > template<typename Descriptor, template<typename Type> class Allocator> > -typename hash_table<Descriptor, Allocator, true>::value_type * > -hash_table<Descriptor, Allocator, true> > +typename hash_table<Descriptor, Allocator>::value_type * > +hash_table<Descriptor, Allocator> > ::find_slot_with_hash (const compare_type &comparable, hashval_t hash, > enum insert_option insert) > { > @@ -1599,7 +1063,7 @@ hash_table<Descriptor, Allocator, true> > > template<typename Descriptor, template<typename Type> class Allocator> > void > -hash_table<Descriptor, Allocator, true> > +hash_table<Descriptor, Allocator> > ::remove_elt_with_hash (const compare_type &comparable, hashval_t hash) > { > value_type *slot = find_slot_with_hash (comparable, hash, NO_INSERT); > @@ -1619,11 +1083,11 @@ hash_table<Descriptor, Allocator, true> > template<typename Descriptor, > template<typename Type> class Allocator> > template<typename Argument, > - int (*Callback) (typename hash_table<Descriptor, Allocator, > - true>::value_type *slot, > - Argument argument)> > + int (*Callback) > + (typename hash_table<Descriptor, Allocator>::value_type *slot, > + Argument argument)> > void > -hash_table<Descriptor, Allocator, true>::traverse_noresize (Argument argument) > +hash_table<Descriptor, Allocator>::traverse_noresize (Argument argument) > { > value_type *slot = m_entries; > value_type *limit = slot + size (); > @@ -1645,11 +1109,11 @@ hash_table<Descriptor, Allocator, true>::traverse_noresize (Argument argument) > template <typename Descriptor, > template <typename Type> class Allocator> > template <typename Argument, > - int (*Callback) (typename hash_table<Descriptor, Allocator, > - true>::value_type *slot, > - Argument argument)> > + int (*Callback) > + (typename hash_table<Descriptor, Allocator>::value_type *slot, > + Argument argument)> > void > -hash_table<Descriptor, Allocator, true>::traverse (Argument argument) > +hash_table<Descriptor, Allocator>::traverse (Argument argument) > { > size_t size = m_size; > if (elements () * 8 < size && size > 32) > @@ -1662,7 +1126,7 @@ hash_table<Descriptor, Allocator, true>::traverse (Argument argument) > > template<typename Descriptor, template<typename Type> class Allocator> > void > -hash_table<Descriptor, Allocator, true>::iterator::slide () > +hash_table<Descriptor, Allocator>::iterator::slide () > { > for ( ; m_slot < m_limit; ++m_slot ) > { > @@ -1677,8 +1141,8 @@ hash_table<Descriptor, Allocator, true>::iterator::slide () > /* Bump the iterator. */ > > template<typename Descriptor, template<typename Type> class Allocator> > -inline typename hash_table<Descriptor, Allocator, true>::iterator & > -hash_table<Descriptor, Allocator, true>::iterator::operator ++ () > +inline typename hash_table<Descriptor, Allocator>::iterator & > +hash_table<Descriptor, Allocator>::iterator::operator ++ () > { > ++m_slot; > slide (); > diff --git a/gcc/ipa-devirt.c b/gcc/ipa-devirt.c > index 6969f5a..7214a74 100644 > --- a/gcc/ipa-devirt.c > +++ b/gcc/ipa-devirt.c > @@ -308,11 +308,11 @@ type_possibly_instantiated_p (tree t) > > struct odr_name_hasher > { > - typedef odr_type_d value_type; > - typedef union tree_node compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > - static inline void remove (value_type *); > + typedef odr_type_d *value_type; > + typedef union tree_node *compare_type; > + static inline hashval_t hash (const odr_type_d *); > + static inline bool equal (const odr_type_d *, const tree_node *); > + static inline void remove (odr_type_d *); > }; > > /* Has used to unify ODR types based on their associated virtual table. > @@ -321,8 +321,8 @@ struct odr_name_hasher > > struct odr_vtable_hasher:odr_name_hasher > { > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + static inline hashval_t hash (const odr_type_d *); > + static inline bool equal (const odr_type_d *, const tree_node *); > }; > > /* Return type that was declared with T's name so that T is an > @@ -369,7 +369,7 @@ hash_odr_name (const_tree t) > /* Return the computed hashcode for ODR_TYPE. */ > > inline hashval_t > -odr_name_hasher::hash (const value_type *odr_type) > +odr_name_hasher::hash (const odr_type_d *odr_type) > { > return hash_odr_name (odr_type->type); > } > @@ -414,7 +414,7 @@ hash_odr_vtable (const_tree t) > /* Return the computed hashcode for ODR_TYPE. */ > > inline hashval_t > -odr_vtable_hasher::hash (const value_type *odr_type) > +odr_vtable_hasher::hash (const odr_type_d *odr_type) > { > return hash_odr_vtable (odr_type->type); > } > @@ -553,7 +553,7 @@ types_must_be_same_for_odr (tree t1, tree t2) > equivalent. */ > > inline bool > -odr_name_hasher::equal (const value_type *o1, const compare_type *t2) > +odr_name_hasher::equal (const odr_type_d *o1, const tree_node *t2) > { > tree t1 = o1->type; > > @@ -578,7 +578,7 @@ odr_name_hasher::equal (const value_type *o1, const compare_type *t2) > equivalent. */ > > inline bool > -odr_vtable_hasher::equal (const value_type *o1, const compare_type *t2) > +odr_vtable_hasher::equal (const odr_type_d *o1, const tree_node *t2) > { > tree t1 = o1->type; > > @@ -602,7 +602,7 @@ odr_vtable_hasher::equal (const value_type *o1, const compare_type *t2) > /* Free ODR type V. */ > > inline void > -odr_name_hasher::remove (value_type *v) > +odr_name_hasher::remove (odr_type_d *v) > { > v->bases.release (); > v->derived_types.release (); > @@ -2507,17 +2507,18 @@ struct polymorphic_call_target_d > > struct polymorphic_call_target_hasher > { > - typedef polymorphic_call_target_d value_type; > - typedef polymorphic_call_target_d compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > - static inline void remove (value_type *); > + typedef polymorphic_call_target_d *value_type; > + typedef polymorphic_call_target_d *compare_type; > + static inline hashval_t hash (const polymorphic_call_target_d *); > + static inline bool equal (const polymorphic_call_target_d *, > + const polymorphic_call_target_d *); > + static inline void remove (polymorphic_call_target_d *); > }; > > /* Return the computed hashcode for ODR_QUERY. */ > > inline hashval_t > -polymorphic_call_target_hasher::hash (const value_type *odr_query) > +polymorphic_call_target_hasher::hash (const polymorphic_call_target_d *odr_query) > { > inchash::hash hstate (odr_query->otr_token); > > @@ -2541,8 +2542,8 @@ polymorphic_call_target_hasher::hash (const value_type *odr_query) > /* Compare cache entries T1 and T2. */ > > inline bool > -polymorphic_call_target_hasher::equal (const value_type *t1, > - const compare_type *t2) > +polymorphic_call_target_hasher::equal (const polymorphic_call_target_d *t1, > + const polymorphic_call_target_d *t2) > { > return (t1->type == t2->type && t1->otr_token == t2->otr_token > && t1->speculative == t2->speculative > @@ -2560,7 +2561,7 @@ polymorphic_call_target_hasher::equal (const value_type *t1, > /* Remove entry in polymorphic call target cache hash. */ > > inline void > -polymorphic_call_target_hasher::remove (value_type *v) > +polymorphic_call_target_hasher::remove (polymorphic_call_target_d *v) > { > v->targets.release (); > free (v); > diff --git a/gcc/ipa-icf.h b/gcc/ipa-icf.h > index 7eb9f27..b9d70b4 100644 > --- a/gcc/ipa-icf.h > +++ b/gcc/ipa-icf.h > @@ -429,15 +429,16 @@ struct congruence_class_group > /* Congruence class set structure. */ > struct congruence_class_group_hash: typed_noop_remove <congruence_class_group> > { > - typedef congruence_class_group value_type; > - typedef congruence_class_group compare_type; > + typedef congruence_class_group *value_type; > + typedef congruence_class_group *compare_type; > > - static inline hashval_t hash (const value_type *item) > + static inline hashval_t hash (const congruence_class_group *item) > { > return item->hash; > } > > - static inline int equal (const value_type *item1, const compare_type *item2) > + static inline int equal (const congruence_class_group *item1, > + const congruence_class_group *item2) > { > return item1->hash == item2->hash && item1->type == item2->type; > } > diff --git a/gcc/ipa-profile.c b/gcc/ipa-profile.c > index e9f937f..96fb810 100644 > --- a/gcc/ipa-profile.c > +++ b/gcc/ipa-profile.c > @@ -113,10 +113,10 @@ static alloc_pool histogram_pool; > > struct histogram_hash : typed_noop_remove <histogram_entry> > { > - typedef histogram_entry value_type; > - typedef histogram_entry compare_type; > - static inline hashval_t hash (const value_type *); > - static inline int equal (const value_type *, const compare_type *); > + typedef histogram_entry *value_type; > + typedef histogram_entry *compare_type; > + static inline hashval_t hash (const histogram_entry *); > + static inline int equal (const histogram_entry *, const histogram_entry *); > }; > > inline hashval_t > diff --git a/gcc/ira-color.c b/gcc/ira-color.c > index ff1fe8a..bc0692d 100644 > --- a/gcc/ira-color.c > +++ b/gcc/ira-color.c > @@ -227,22 +227,24 @@ static vec<allocno_hard_regs_t> allocno_hard_regs_vec; > > struct allocno_hard_regs_hasher : typed_noop_remove <allocno_hard_regs> > { > - typedef allocno_hard_regs value_type; > - typedef allocno_hard_regs compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef allocno_hard_regs *value_type; > + typedef allocno_hard_regs *compare_type; > + static inline hashval_t hash (const allocno_hard_regs *); > + static inline bool equal (const allocno_hard_regs *, > + const allocno_hard_regs *); > }; > > /* Returns hash value for allocno hard registers V. */ > inline hashval_t > -allocno_hard_regs_hasher::hash (const value_type *hv) > +allocno_hard_regs_hasher::hash (const allocno_hard_regs *hv) > { > return iterative_hash (&hv->set, sizeof (HARD_REG_SET), 0); > } > > /* Compares allocno hard registers V1 and V2. */ > inline bool > -allocno_hard_regs_hasher::equal (const value_type *hv1, const compare_type *hv2) > +allocno_hard_regs_hasher::equal (const allocno_hard_regs *hv1, > + const allocno_hard_regs *hv2) > { > return hard_reg_set_equal_p (hv1->set, hv2->set); > } > diff --git a/gcc/ira-costs.c b/gcc/ira-costs.c > index 354ba6b..5358440 100644 > --- a/gcc/ira-costs.c > +++ b/gcc/ira-costs.c > @@ -161,23 +161,23 @@ static cost_classes_t *regno_cost_classes; > > struct cost_classes_hasher > { > - typedef cost_classes value_type; > - typedef cost_classes compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > - static inline void remove (value_type *); > + typedef cost_classes *value_type; > + typedef cost_classes *compare_type; > + static inline hashval_t hash (const cost_classes *); > + static inline bool equal (const cost_classes *, const cost_classes *); > + static inline void remove (cost_classes *); > }; > > /* Returns hash value for cost classes info HV. */ > inline hashval_t > -cost_classes_hasher::hash (const value_type *hv) > +cost_classes_hasher::hash (const cost_classes *hv) > { > return iterative_hash (&hv->classes, sizeof (enum reg_class) * hv->num, 0); > } > > /* Compares cost classes info HV1 and HV2. */ > inline bool > -cost_classes_hasher::equal (const value_type *hv1, const compare_type *hv2) > +cost_classes_hasher::equal (const cost_classes *hv1, const cost_classes *hv2) > { > return (hv1->num == hv2->num > && memcmp (hv1->classes, hv2->classes, > @@ -186,7 +186,7 @@ cost_classes_hasher::equal (const value_type *hv1, const compare_type *hv2) > > /* Delete cost classes info V from the hash table. */ > inline void > -cost_classes_hasher::remove (value_type *v) > +cost_classes_hasher::remove (cost_classes *v) > { > ira_free (v); > } > diff --git a/gcc/java/jcf-io.c b/gcc/java/jcf-io.c > index 2c48f14..36ceb07 100644 > --- a/gcc/java/jcf-io.c > +++ b/gcc/java/jcf-io.c > @@ -285,21 +285,20 @@ find_classfile (char *filename, JCF *jcf, const char *dep_name) > > struct charstar_hash : typed_noop_remove <char> > { > - typedef const char value_type; > - typedef const char compare_type; > - static inline hashval_t hash (const value_type *candidate); > - static inline bool equal (const value_type *existing, > - const compare_type *candidate); > + typedef const char *value_type; > + typedef const char *compare_type; > + static inline hashval_t hash (const char *candidate); > + static inline bool equal (const char *existing, const char *candidate); > }; > > inline hashval_t > -charstar_hash::hash (const value_type *candidate) > +charstar_hash::hash (const char *candidate) > { > return htab_hash_string (candidate); > } > > inline bool > -charstar_hash::equal (const value_type *existing, const compare_type *candidate) > +charstar_hash::equal (const char *existing, const char *candidate) > { > return strcmp (existing, candidate) == 0; > } > diff --git a/gcc/loop-invariant.c b/gcc/loop-invariant.c > index f79b497..52ecc05 100644 > --- a/gcc/loop-invariant.c > +++ b/gcc/loop-invariant.c > @@ -455,16 +455,17 @@ invariant_expr_equal_p (rtx_insn *insn1, rtx e1, rtx_insn *insn2, rtx e2) > > struct invariant_expr_hasher : typed_free_remove <invariant_expr_entry> > { > - typedef invariant_expr_entry value_type; > - typedef invariant_expr_entry compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef invariant_expr_entry *value_type; > + typedef invariant_expr_entry *compare_type; > + static inline hashval_t hash (const invariant_expr_entry *); > + static inline bool equal (const invariant_expr_entry *, > + const invariant_expr_entry *); > }; > > /* Returns hash value for invariant expression entry ENTRY. */ > > inline hashval_t > -invariant_expr_hasher::hash (const value_type *entry) > +invariant_expr_hasher::hash (const invariant_expr_entry *entry) > { > return entry->hash; > } > @@ -472,8 +473,8 @@ invariant_expr_hasher::hash (const value_type *entry) > /* Compares invariant expression entries ENTRY1 and ENTRY2. */ > > inline bool > -invariant_expr_hasher::equal (const value_type *entry1, > - const compare_type *entry2) > +invariant_expr_hasher::equal (const invariant_expr_entry *entry1, > + const invariant_expr_entry *entry2) > { > if (entry1->mode != entry2->mode) > return 0; > diff --git a/gcc/loop-iv.c b/gcc/loop-iv.c > index de2b15a..36a9a9f 100644 > --- a/gcc/loop-iv.c > +++ b/gcc/loop-iv.c > @@ -138,16 +138,16 @@ static struct loop *current_loop; > > struct biv_entry_hasher : typed_free_remove <biv_entry> > { > - typedef biv_entry value_type; > - typedef rtx_def compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef biv_entry *value_type; > + typedef rtx_def *compare_type; > + static inline hashval_t hash (const biv_entry *); > + static inline bool equal (const biv_entry *, const rtx_def *); > }; > > /* Returns hash value for biv B. */ > > inline hashval_t > -biv_entry_hasher::hash (const value_type *b) > +biv_entry_hasher::hash (const biv_entry *b) > { > return b->regno; > } > @@ -155,7 +155,7 @@ biv_entry_hasher::hash (const value_type *b) > /* Compares biv B and register R. */ > > inline bool > -biv_entry_hasher::equal (const value_type *b, const compare_type *r) > +biv_entry_hasher::equal (const biv_entry *b, const rtx_def *r) > { > return b->regno == REGNO (r); > } > diff --git a/gcc/loop-unroll.c b/gcc/loop-unroll.c > index 2befb61..ccf473d 100644 > --- a/gcc/loop-unroll.c > +++ b/gcc/loop-unroll.c > @@ -126,17 +126,17 @@ struct var_to_expand > > struct iv_split_hasher : typed_free_remove <iv_to_split> > { > - typedef iv_to_split value_type; > - typedef iv_to_split compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef iv_to_split *value_type; > + typedef iv_to_split *compare_type; > + static inline hashval_t hash (const iv_to_split *); > + static inline bool equal (const iv_to_split *, const iv_to_split *); > }; > > > /* A hash function for information about insns to split. */ > > inline hashval_t > -iv_split_hasher::hash (const value_type *ivts) > +iv_split_hasher::hash (const iv_to_split *ivts) > { > return (hashval_t) INSN_UID (ivts->insn); > } > @@ -144,7 +144,7 @@ iv_split_hasher::hash (const value_type *ivts) > /* An equality functions for information about insns to split. */ > > inline bool > -iv_split_hasher::equal (const value_type *i1, const compare_type *i2) > +iv_split_hasher::equal (const iv_to_split *i1, const iv_to_split *i2) > { > return i1->insn == i2->insn; > } > @@ -153,16 +153,16 @@ iv_split_hasher::equal (const value_type *i1, const compare_type *i2) > > struct var_expand_hasher : typed_free_remove <var_to_expand> > { > - typedef var_to_expand value_type; > - typedef var_to_expand compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef var_to_expand *value_type; > + typedef var_to_expand *compare_type; > + static inline hashval_t hash (const var_to_expand *); > + static inline bool equal (const var_to_expand *, const var_to_expand *); > }; > > /* Return a hash for VES. */ > > inline hashval_t > -var_expand_hasher::hash (const value_type *ves) > +var_expand_hasher::hash (const var_to_expand *ves) > { > return (hashval_t) INSN_UID (ves->insn); > } > @@ -170,7 +170,7 @@ var_expand_hasher::hash (const value_type *ves) > /* Return true if I1 and I2 refer to the same instruction. */ > > inline bool > -var_expand_hasher::equal (const value_type *i1, const compare_type *i2) > +var_expand_hasher::equal (const var_to_expand *i1, const var_to_expand *i2) > { > return i1->insn == i2->insn; > } > diff --git a/gcc/lto-streamer.h b/gcc/lto-streamer.h > index b383631..e3465a8 100644 > --- a/gcc/lto-streamer.h > +++ b/gcc/lto-streamer.h > @@ -657,17 +657,17 @@ struct string_slot > > struct string_slot_hasher : typed_noop_remove <string_slot> > { > - typedef string_slot value_type; > - typedef string_slot compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef string_slot *value_type; > + typedef string_slot *compare_type; > + static inline hashval_t hash (const string_slot *); > + static inline bool equal (const string_slot *, const string_slot *); > }; > > /* Returns a hash code for DS. Adapted from libiberty's htab_hash_string > to support strings that may not end in '\0'. */ > > inline hashval_t > -string_slot_hasher::hash (const value_type *ds) > +string_slot_hasher::hash (const string_slot *ds) > { > hashval_t r = ds->len; > int i; > @@ -680,7 +680,7 @@ string_slot_hasher::hash (const value_type *ds) > /* Returns nonzero if DS1 and DS2 are equal. */ > > inline bool > -string_slot_hasher::equal (const value_type *ds1, const compare_type *ds2) > +string_slot_hasher::equal (const string_slot *ds1, const string_slot *ds2) > { > if (ds1->len == ds2->len) > return memcmp (ds1->s, ds2->s, ds1->len) == 0; > diff --git a/gcc/lto/lto.c b/gcc/lto/lto.c > index 360aeed..f3458c7 100644 > --- a/gcc/lto/lto.c > +++ b/gcc/lto/lto.c > @@ -1143,20 +1143,20 @@ struct tree_scc > > struct tree_scc_hasher : typed_noop_remove <tree_scc> > { > - typedef tree_scc value_type; > - typedef tree_scc compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef tree_scc *value_type; > + typedef tree_scc *compare_type; > + static inline hashval_t hash (const tree_scc *); > + static inline bool equal (const tree_scc *, const tree_scc *); > }; > > hashval_t > -tree_scc_hasher::hash (const value_type *scc) > +tree_scc_hasher::hash (const tree_scc *scc) > { > return scc->hash; > } > > bool > -tree_scc_hasher::equal (const value_type *scc1, const compare_type *scc2) > +tree_scc_hasher::equal (const tree_scc *scc1, const tree_scc *scc2) > { > if (scc1->hash != scc2->hash > || scc1->len != scc2->len > diff --git a/gcc/objc/objc-act.c b/gcc/objc/objc-act.c > index 6bd4dcc..718fdf0 100644 > --- a/gcc/objc/objc-act.c > +++ b/gcc/objc/objc-act.c > @@ -3871,20 +3871,20 @@ objc_get_class_ivars (tree class_name) > > struct decl_name_hash : typed_noop_remove <tree_node> > { > - typedef tree_node value_type; > - typedef tree_node compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef tree_node *value_type; > + typedef tree_node *compare_type; > + static inline hashval_t hash (const tree_node *); > + static inline bool equal (const tree_node *, const tree_node *); > }; > > inline hashval_t > -decl_name_hash::hash (const value_type *q) > +decl_name_hash::hash (const tree_node *q) > { > return (hashval_t) ((intptr_t)(DECL_NAME (q)) >> 3); > } > > inline bool > -decl_name_hash::equal (const value_type *a, const compare_type *b) > +decl_name_hash::equal (const tree_node *a, const tree_node *b) > { > return DECL_NAME (a) == DECL_NAME (b); > } > diff --git a/gcc/plugin.c b/gcc/plugin.c > index d924438..6a7654f 100644 > --- a/gcc/plugin.c > +++ b/gcc/plugin.c > @@ -66,16 +66,16 @@ const char **plugin_event_name = plugin_event_name_init; > > struct event_hasher : typed_noop_remove <const char *> > { > - typedef const char *value_type; > - typedef const char *compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef const char **value_type; > + typedef const char **compare_type; > + static inline hashval_t hash (const char **); > + static inline bool equal (const char **, const char **); > }; > > /* Helper function for the event hash table that hashes the entry V. */ > > inline hashval_t > -event_hasher::hash (const value_type *v) > +event_hasher::hash (const char **v) > { > return htab_hash_string (*v); > } > @@ -84,7 +84,7 @@ event_hasher::hash (const value_type *v) > existing entry (S1) with the given string (S2). */ > > inline bool > -event_hasher::equal (const value_type *s1, const compare_type *s2) > +event_hasher::equal (const char **s1, const char **s2) > { > return !strcmp (*s1, *s2); > } > diff --git a/gcc/postreload-gcse.c b/gcc/postreload-gcse.c > index 83048bd..9014d69 100644 > --- a/gcc/postreload-gcse.c > +++ b/gcc/postreload-gcse.c > @@ -134,10 +134,10 @@ struct expr > > struct expr_hasher : typed_noop_remove <expr> > { > - typedef expr value_type; > - typedef expr compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef expr *value_type; > + typedef expr *compare_type; > + static inline hashval_t hash (const expr *); > + static inline bool equal (const expr *, const expr *); > }; > > > @@ -159,7 +159,7 @@ hash_expr (rtx x, int *do_not_record_p) > here, we just return the cached hash value. */ > > inline hashval_t > -expr_hasher::hash (const value_type *exp) > +expr_hasher::hash (const expr *exp) > { > return exp->hash; > } > @@ -168,7 +168,7 @@ expr_hasher::hash (const value_type *exp) > Return nonzero if exp1 is equivalent to exp2. */ > > inline bool > -expr_hasher::equal (const value_type *exp1, const compare_type *exp2) > +expr_hasher::equal (const expr *exp1, const expr *exp2) > { > int equiv_p = exp_equiv_p (exp1->expr, exp2->expr, 0, true); > > diff --git a/gcc/reginfo.c b/gcc/reginfo.c > index 9015eeb..6678688 100644 > --- a/gcc/reginfo.c > +++ b/gcc/reginfo.c > @@ -85,15 +85,6 @@ struct simplifiable_subreg > subreg_shape shape; > HARD_REG_SET simplifiable_regs; > }; > - > -struct simplifiable_subregs_hasher : typed_noop_remove <simplifiable_subreg> > -{ > - typedef simplifiable_subreg value_type; > - typedef subreg_shape compare_type; > - > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > -}; > > struct target_hard_regs default_target_hard_regs; > struct target_regs default_target_regs; > @@ -1234,14 +1225,14 @@ reg_classes_intersect_p (reg_class_t c1, reg_class_t c2) > > > inline hashval_t > -simplifiable_subregs_hasher::hash (const value_type *value) > +simplifiable_subregs_hasher::hash (const simplifiable_subreg *value) > { > return value->shape.unique_id (); > } > > inline bool > -simplifiable_subregs_hasher::equal (const value_type *value, > - const compare_type *compare) > +simplifiable_subregs_hasher::equal (const simplifiable_subreg *value, > + const subreg_shape *compare) > { > return value->shape == *compare; > } > diff --git a/gcc/statistics.c b/gcc/statistics.c > index b76de15..8cbe88d 100644 > --- a/gcc/statistics.c > +++ b/gcc/statistics.c > @@ -55,17 +55,18 @@ typedef struct statistics_counter_s { > > struct stats_counter_hasher > { > - typedef statistics_counter_t value_type; > - typedef statistics_counter_t compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > - static inline void remove (value_type *); > + typedef statistics_counter_t *value_type; > + typedef statistics_counter_t *compare_type; > + static inline hashval_t hash (const statistics_counter_t *); > + static inline bool equal (const statistics_counter_t *, > + const statistics_counter_t *); > + static inline void remove (statistics_counter_t *); > }; > > /* Hash a statistic counter by its string ID. */ > > inline hashval_t > -stats_counter_hasher::hash (const value_type *c) > +stats_counter_hasher::hash (const statistics_counter_t *c) > { > return htab_hash_string (c->id) + c->val; > } > @@ -73,7 +74,8 @@ stats_counter_hasher::hash (const value_type *c) > /* Compare two statistic counters by their string IDs. */ > > inline bool > -stats_counter_hasher::equal (const value_type *c1, const compare_type *c2) > +stats_counter_hasher::equal (const statistics_counter_t *c1, > + const statistics_counter_t *c2) > { > return c1->val == c2->val && strcmp (c1->id, c2->id) == 0; > } > @@ -81,7 +83,7 @@ stats_counter_hasher::equal (const value_type *c1, const compare_type *c2) > /* Free a statistics entry. */ > > inline void > -stats_counter_hasher::remove (value_type *v) > +stats_counter_hasher::remove (statistics_counter_t *v) > { > free (CONST_CAST (char *, v->id)); > free (v); > diff --git a/gcc/store-motion.c b/gcc/store-motion.c > index 530766f..d621ec1 100644 > --- a/gcc/store-motion.c > +++ b/gcc/store-motion.c > @@ -137,21 +137,21 @@ static struct edge_list *edge_list; > > struct st_expr_hasher : typed_noop_remove <st_expr> > { > - typedef st_expr value_type; > - typedef st_expr compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef st_expr *value_type; > + typedef st_expr *compare_type; > + static inline hashval_t hash (const st_expr *); > + static inline bool equal (const st_expr *, const st_expr *); > }; > > inline hashval_t > -st_expr_hasher::hash (const value_type *x) > +st_expr_hasher::hash (const st_expr *x) > { > int do_not_record_p = 0; > return hash_rtx (x->pattern, GET_MODE (x->pattern), &do_not_record_p, NULL, false); > } > > inline bool > -st_expr_hasher::equal (const value_type *ptr1, const compare_type *ptr2) > +st_expr_hasher::equal (const st_expr *ptr1, const st_expr *ptr2) > { > return exp_equiv_p (ptr1->pattern, ptr2->pattern, 0, true); > } > diff --git a/gcc/trans-mem.c b/gcc/trans-mem.c > index 078c2da..d6cbd76 100644 > --- a/gcc/trans-mem.c > +++ b/gcc/trans-mem.c > @@ -974,23 +974,23 @@ typedef struct tm_log_entry > > struct log_entry_hasher > { > - typedef tm_log_entry value_type; > - typedef tm_log_entry compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > - static inline void remove (value_type *); > + typedef tm_log_entry *value_type; > + typedef tm_log_entry *compare_type; > + static inline hashval_t hash (const tm_log_entry *); > + static inline bool equal (const tm_log_entry *, const tm_log_entry *); > + static inline void remove (tm_log_entry *); > }; > > /* Htab support. Return hash value for a `tm_log_entry'. */ > inline hashval_t > -log_entry_hasher::hash (const value_type *log) > +log_entry_hasher::hash (const tm_log_entry *log) > { > return iterative_hash_expr (log->addr, 0); > } > > /* Htab support. Return true if two log entries are the same. */ > inline bool > -log_entry_hasher::equal (const value_type *log1, const compare_type *log2) > +log_entry_hasher::equal (const tm_log_entry *log1, const tm_log_entry *log2) > { > /* FIXME: > > @@ -1016,7 +1016,7 @@ log_entry_hasher::equal (const value_type *log1, const compare_type *log2) > > /* Htab support. Free one tm_log_entry. */ > inline void > -log_entry_hasher::remove (value_type *lp) > +log_entry_hasher::remove (tm_log_entry *lp) > { > lp->stmts.release (); > free (lp); > @@ -1049,20 +1049,20 @@ typedef struct tm_new_mem_map > > struct tm_mem_map_hasher : typed_free_remove <tm_new_mem_map_t> > { > - typedef tm_new_mem_map_t value_type; > - typedef tm_new_mem_map_t compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef tm_new_mem_map_t *value_type; > + typedef tm_new_mem_map_t *compare_type; > + static inline hashval_t hash (const tm_new_mem_map_t *); > + static inline bool equal (const tm_new_mem_map_t *, const tm_new_mem_map_t *); > }; > > inline hashval_t > -tm_mem_map_hasher::hash (const value_type *v) > +tm_mem_map_hasher::hash (const tm_new_mem_map_t *v) > { > return (intptr_t)v->val >> 4; > } > > inline bool > -tm_mem_map_hasher::equal (const value_type *v, const compare_type *c) > +tm_mem_map_hasher::equal (const tm_new_mem_map_t *v, const tm_new_mem_map_t *c) > { > return v->val == c->val; > } > @@ -3350,15 +3350,15 @@ typedef struct tm_memop > > struct tm_memop_hasher : typed_free_remove <tm_memop> > { > - typedef tm_memop value_type; > - typedef tm_memop compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef tm_memop *value_type; > + typedef tm_memop *compare_type; > + static inline hashval_t hash (const tm_memop *); > + static inline bool equal (const tm_memop *, const tm_memop *); > }; > > /* Htab support. Return a hash value for a `tm_memop'. */ > inline hashval_t > -tm_memop_hasher::hash (const value_type *mem) > +tm_memop_hasher::hash (const tm_memop *mem) > { > tree addr = mem->addr; > /* We drill down to the SSA_NAME/DECL for the hash, but equality is > @@ -3370,7 +3370,7 @@ tm_memop_hasher::hash (const value_type *mem) > > /* Htab support. Return true if two tm_memop's are the same. */ > inline bool > -tm_memop_hasher::equal (const value_type *mem1, const compare_type *mem2) > +tm_memop_hasher::equal (const tm_memop *mem1, const tm_memop *mem2) > { > return operand_equal_p (mem1->addr, mem2->addr, 0); > } > diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c > index 64bdc92..c03dfed 100644 > --- a/gcc/tree-cfg.c > +++ b/gcc/tree-cfg.c > @@ -148,17 +148,18 @@ struct locus_discrim_map > > struct locus_discrim_hasher : typed_free_remove <locus_discrim_map> > { > - typedef locus_discrim_map value_type; > - typedef locus_discrim_map compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef locus_discrim_map *value_type; > + typedef locus_discrim_map *compare_type; > + static inline hashval_t hash (const locus_discrim_map *); > + static inline bool equal (const locus_discrim_map *, > + const locus_discrim_map *); > }; > > /* Trivial hash function for a location_t. ITEM is a pointer to > a hash table entry that maps a location_t to a discriminator. */ > > inline hashval_t > -locus_discrim_hasher::hash (const value_type *item) > +locus_discrim_hasher::hash (const locus_discrim_map *item) > { > return LOCATION_LINE (item->locus); > } > @@ -167,7 +168,8 @@ locus_discrim_hasher::hash (const value_type *item) > point to the two hash table entries to compare. */ > > inline bool > -locus_discrim_hasher::equal (const value_type *a, const compare_type *b) > +locus_discrim_hasher::equal (const locus_discrim_map *a, > + const locus_discrim_map *b) > { > return LOCATION_LINE (a->locus) == LOCATION_LINE (b->locus); > } > diff --git a/gcc/tree-eh.c b/gcc/tree-eh.c > index a111e9d..5d41cb4 100644 > --- a/gcc/tree-eh.c > +++ b/gcc/tree-eh.c > @@ -214,20 +214,22 @@ struct finally_tree_node > > struct finally_tree_hasher : typed_free_remove <finally_tree_node> > { > - typedef finally_tree_node value_type; > - typedef finally_tree_node compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef finally_tree_node *value_type; > + typedef finally_tree_node *compare_type; > + static inline hashval_t hash (const finally_tree_node *); > + static inline bool equal (const finally_tree_node *, > + const finally_tree_node *); > }; > > inline hashval_t > -finally_tree_hasher::hash (const value_type *v) > +finally_tree_hasher::hash (const finally_tree_node *v) > { > return (intptr_t)v->child.t >> 4; > } > > inline bool > -finally_tree_hasher::equal (const value_type *v, const compare_type *c) > +finally_tree_hasher::equal (const finally_tree_node *v, > + const finally_tree_node *c) > { > return v->child.t == c->child.t; > } > diff --git a/gcc/tree-hasher.h b/gcc/tree-hasher.h > index 35eb9b2..228e317 100644 > --- a/gcc/tree-hasher.h > +++ b/gcc/tree-hasher.h > @@ -34,7 +34,6 @@ struct int_tree_hasher > { > typedef int_tree_map value_type; > typedef int_tree_map compare_type; > - typedef int store_values_directly; > static inline hashval_t hash (const value_type &); > static inline bool equal (const value_type &, const compare_type &); > static bool is_deleted (const value_type &v) > diff --git a/gcc/tree-into-ssa.c b/gcc/tree-into-ssa.c > index 2589628..e8b55c1 100644 > --- a/gcc/tree-into-ssa.c > +++ b/gcc/tree-into-ssa.c > @@ -232,7 +232,6 @@ struct var_info_hasher : typed_free_remove <var_info_d> > { > typedef var_info_d *value_type; > typedef var_info_d *compare_type; > - typedef int store_values_directly; > static inline hashval_t hash (const value_type &); > static inline bool equal (const value_type &, const compare_type &); > }; > diff --git a/gcc/tree-parloops.c b/gcc/tree-parloops.c > index 62a6444..080d35e 100644 > --- a/gcc/tree-parloops.c > +++ b/gcc/tree-parloops.c > @@ -228,22 +228,22 @@ struct reduction_info > > struct reduction_hasher : typed_free_remove <reduction_info> > { > - typedef reduction_info value_type; > - typedef reduction_info compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef reduction_info *value_type; > + typedef reduction_info *compare_type; > + static inline hashval_t hash (const reduction_info *); > + static inline bool equal (const reduction_info *, const reduction_info *); > }; > > /* Equality and hash functions for hashtab code. */ > > inline bool > -reduction_hasher::equal (const value_type *a, const compare_type *b) > +reduction_hasher::equal (const reduction_info *a, const reduction_info *b) > { > return (a->reduc_phi == b->reduc_phi); > } > > inline hashval_t > -reduction_hasher::hash (const value_type *a) > +reduction_hasher::hash (const reduction_info *a) > { > return a->reduc_version; > } > @@ -280,22 +280,22 @@ struct name_to_copy_elt > > struct name_to_copy_hasher : typed_free_remove <name_to_copy_elt> > { > - typedef name_to_copy_elt value_type; > - typedef name_to_copy_elt compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef name_to_copy_elt *value_type; > + typedef name_to_copy_elt *compare_type; > + static inline hashval_t hash (const name_to_copy_elt *); > + static inline bool equal (const name_to_copy_elt *, const name_to_copy_elt *); > }; > > /* Equality and hash functions for hashtab code. */ > > inline bool > -name_to_copy_hasher::equal (const value_type *a, const compare_type *b) > +name_to_copy_hasher::equal (const name_to_copy_elt *a, const name_to_copy_elt *b) > { > return a->version == b->version; > } > > inline hashval_t > -name_to_copy_hasher::hash (const value_type *a) > +name_to_copy_hasher::hash (const name_to_copy_elt *a) > { > return (hashval_t) a->version; > } > diff --git a/gcc/tree-sra.c b/gcc/tree-sra.c > index 6adee70..4b0d2a8 100644 > --- a/gcc/tree-sra.c > +++ b/gcc/tree-sra.c > @@ -327,16 +327,16 @@ static hash_map<tree, auto_vec<access_p> > *base_access_vec; > > struct uid_decl_hasher : typed_noop_remove <tree_node> > { > - typedef tree_node value_type; > - typedef tree_node compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef tree_node *value_type; > + typedef tree_node *compare_type; > + static inline hashval_t hash (const tree_node *); > + static inline bool equal (const tree_node *, const tree_node *); > }; > > /* Hash a tree in a uid_decl_map. */ > > inline hashval_t > -uid_decl_hasher::hash (const value_type *item) > +uid_decl_hasher::hash (const tree_node *item) > { > return item->decl_minimal.uid; > } > @@ -344,7 +344,7 @@ uid_decl_hasher::hash (const value_type *item) > /* Return true if the DECL_UID in both trees are equal. */ > > inline bool > -uid_decl_hasher::equal (const value_type *a, const compare_type *b) > +uid_decl_hasher::equal (const tree_node *a, const tree_node *b) > { > return (a->decl_minimal.uid == b->decl_minimal.uid); > } > diff --git a/gcc/tree-ssa-coalesce.c b/gcc/tree-ssa-coalesce.c > index 1afeefe..eeac5a4 100644 > --- a/gcc/tree-ssa-coalesce.c > +++ b/gcc/tree-ssa-coalesce.c > @@ -81,16 +81,16 @@ typedef const struct coalesce_pair *const_coalesce_pair_p; > > struct coalesce_pair_hasher : typed_noop_remove <coalesce_pair> > { > - typedef coalesce_pair value_type; > - typedef coalesce_pair compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef coalesce_pair *value_type; > + typedef coalesce_pair *compare_type; > + static inline hashval_t hash (const coalesce_pair *); > + static inline bool equal (const coalesce_pair *, const coalesce_pair *); > }; > > /* Hash function for coalesce list. Calculate hash for PAIR. */ > > inline hashval_t > -coalesce_pair_hasher::hash (const value_type *pair) > +coalesce_pair_hasher::hash (const coalesce_pair *pair) > { > hashval_t a = (hashval_t)(pair->first_element); > hashval_t b = (hashval_t)(pair->second_element); > @@ -102,7 +102,7 @@ coalesce_pair_hasher::hash (const value_type *pair) > returning TRUE if the two pairs are equivalent. */ > > inline bool > -coalesce_pair_hasher::equal (const value_type *p1, const compare_type *p2) > +coalesce_pair_hasher::equal (const coalesce_pair *p1, const coalesce_pair *p2) > { > return (p1->first_element == p2->first_element > && p1->second_element == p2->second_element); > @@ -1253,10 +1253,10 @@ coalesce_partitions (var_map map, ssa_conflicts_p graph, coalesce_list_p cl, > > struct ssa_name_var_hash : typed_noop_remove <tree_node> > { > - typedef union tree_node value_type; > - typedef union tree_node compare_type; > - static inline hashval_t hash (const value_type *); > - static inline int equal (const value_type *, const compare_type *); > + typedef union tree_node *value_type; > + typedef union tree_node *compare_type; > + static inline hashval_t hash (const tree_node *); > + static inline int equal (const tree_node *, const tree_node *); > }; > > inline hashval_t > @@ -1266,7 +1266,7 @@ ssa_name_var_hash::hash (const_tree n) > } > > inline int > -ssa_name_var_hash::equal (const value_type *n1, const compare_type *n2) > +ssa_name_var_hash::equal (const tree_node *n1, const tree_node *n2) > { > return SSA_NAME_VAR (n1) == SSA_NAME_VAR (n2); > } > diff --git a/gcc/tree-ssa-dom.c b/gcc/tree-ssa-dom.c > index 907fa97..c526b58 100644 > --- a/gcc/tree-ssa-dom.c > +++ b/gcc/tree-ssa-dom.c > @@ -182,7 +182,6 @@ struct expr_elt_hasher > { > typedef expr_hash_elt *value_type; > typedef expr_hash_elt *compare_type; > - typedef int store_values_directly; > static inline hashval_t hash (const value_type &); > static inline bool equal (const value_type &, const compare_type &); > static inline void remove (value_type &); > diff --git a/gcc/tree-ssa-live.c b/gcc/tree-ssa-live.c > index df90229..2c7c072 100644 > --- a/gcc/tree-ssa-live.c > +++ b/gcc/tree-ssa-live.c > @@ -104,20 +104,20 @@ static void verify_live_on_entry (tree_live_info_p); > > struct tree_int_map_hasher : typed_noop_remove <tree_int_map> > { > - typedef tree_int_map value_type; > - typedef tree_int_map compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef tree_int_map *value_type; > + typedef tree_int_map *compare_type; > + static inline hashval_t hash (const tree_int_map *); > + static inline bool equal (const tree_int_map *, const tree_int_map *); > }; > > inline hashval_t > -tree_int_map_hasher::hash (const value_type *v) > +tree_int_map_hasher::hash (const tree_int_map *v) > { > return tree_map_base_hash (v); > } > > inline bool > -tree_int_map_hasher::equal (const value_type *v, const compare_type *c) > +tree_int_map_hasher::equal (const tree_int_map *v, const tree_int_map *c) > { > return tree_int_map_eq (v, c); > } > diff --git a/gcc/tree-ssa-loop-im.c b/gcc/tree-ssa-loop-im.c > index 9aba79b..11fc699 100644 > --- a/gcc/tree-ssa-loop-im.c > +++ b/gcc/tree-ssa-loop-im.c > @@ -172,16 +172,16 @@ typedef struct im_mem_ref > > struct mem_ref_hasher : typed_noop_remove <im_mem_ref> > { > - typedef im_mem_ref value_type; > - typedef tree_node compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef im_mem_ref *value_type; > + typedef tree_node *compare_type; > + static inline hashval_t hash (const im_mem_ref *); > + static inline bool equal (const im_mem_ref *, const tree_node *); > }; > > /* A hash function for struct im_mem_ref object OBJ. */ > > inline hashval_t > -mem_ref_hasher::hash (const value_type *mem) > +mem_ref_hasher::hash (const im_mem_ref *mem) > { > return mem->hash; > } > @@ -190,7 +190,7 @@ mem_ref_hasher::hash (const value_type *mem) > memory reference OBJ2. */ > > inline bool > -mem_ref_hasher::equal (const value_type *mem1, const compare_type *obj2) > +mem_ref_hasher::equal (const im_mem_ref *mem1, const tree_node *obj2) > { > return operand_equal_p (mem1->mem.ref, (const_tree) obj2, 0); > } > diff --git a/gcc/tree-ssa-loop-ivopts.c b/gcc/tree-ssa-loop-ivopts.c > index 6c96430..d71e3a4 100644 > --- a/gcc/tree-ssa-loop-ivopts.c > +++ b/gcc/tree-ssa-loop-ivopts.c > @@ -292,16 +292,16 @@ typedef struct iv_cand *iv_cand_p; > > struct iv_inv_expr_hasher : typed_free_remove <iv_inv_expr_ent> > { > - typedef iv_inv_expr_ent value_type; > - typedef iv_inv_expr_ent compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef iv_inv_expr_ent *value_type; > + typedef iv_inv_expr_ent *compare_type; > + static inline hashval_t hash (const iv_inv_expr_ent *); > + static inline bool equal (const iv_inv_expr_ent *, const iv_inv_expr_ent *); > }; > > /* Hash function for loop invariant expressions. */ > > inline hashval_t > -iv_inv_expr_hasher::hash (const value_type *expr) > +iv_inv_expr_hasher::hash (const iv_inv_expr_ent *expr) > { > return expr->hash; > } > @@ -309,7 +309,8 @@ iv_inv_expr_hasher::hash (const value_type *expr) > /* Hash table equality function for expressions. */ > > inline bool > -iv_inv_expr_hasher::equal (const value_type *expr1, const compare_type *expr2) > +iv_inv_expr_hasher::equal (const iv_inv_expr_ent *expr1, > + const iv_inv_expr_ent *expr2) > { > return expr1->hash == expr2->hash > && operand_equal_p (expr1->expr, expr2->expr, 0); > diff --git a/gcc/tree-ssa-phiopt.c b/gcc/tree-ssa-phiopt.c > index 14a7122..7c846c2 100644 > --- a/gcc/tree-ssa-phiopt.c > +++ b/gcc/tree-ssa-phiopt.c > @@ -1332,10 +1332,10 @@ struct name_to_bb > > struct ssa_names_hasher : typed_free_remove <name_to_bb> > { > - typedef name_to_bb value_type; > - typedef name_to_bb compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef name_to_bb *value_type; > + typedef name_to_bb *compare_type; > + static inline hashval_t hash (const name_to_bb *); > + static inline bool equal (const name_to_bb *, const name_to_bb *); > }; > > /* Used for quick clearing of the hash-table when we see calls. > @@ -1345,7 +1345,7 @@ static unsigned int nt_call_phase; > /* The hash function. */ > > inline hashval_t > -ssa_names_hasher::hash (const value_type *n) > +ssa_names_hasher::hash (const name_to_bb *n) > { > return n->ssa_name_ver ^ (((hashval_t) n->store) << 31) > ^ (n->offset << 6) ^ (n->size << 3); > @@ -1354,7 +1354,7 @@ ssa_names_hasher::hash (const value_type *n) > /* The equality function of *P1 and *P2. */ > > inline bool > -ssa_names_hasher::equal (const value_type *n1, const compare_type *n2) > +ssa_names_hasher::equal (const name_to_bb *n1, const name_to_bb *n2) > { > return n1->ssa_name_ver == n2->ssa_name_ver > && n1->store == n2->store > diff --git a/gcc/tree-ssa-pre.c b/gcc/tree-ssa-pre.c > index c985e79..d857d84 100644 > --- a/gcc/tree-ssa-pre.c > +++ b/gcc/tree-ssa-pre.c > @@ -228,8 +228,8 @@ typedef struct pre_expr_d : typed_noop_remove <pre_expr_d> > pre_expr_union u; > > /* hash_table support. */ > - typedef pre_expr_d value_type; > - typedef pre_expr_d compare_type; > + typedef pre_expr_d *value_type; > + typedef pre_expr_d *compare_type; > static inline hashval_t hash (const pre_expr_d *); > static inline int equal (const pre_expr_d *, const pre_expr_d *); > } *pre_expr; > @@ -242,7 +242,7 @@ typedef struct pre_expr_d : typed_noop_remove <pre_expr_d> > /* Compare E1 and E1 for equality. */ > > inline int > -pre_expr_d::equal (const value_type *e1, const compare_type *e2) > +pre_expr_d::equal (const pre_expr_d *e1, const pre_expr_d *e2) > { > if (e1->kind != e2->kind) > return false; > @@ -267,7 +267,7 @@ pre_expr_d::equal (const value_type *e1, const compare_type *e2) > /* Hash E. */ > > inline hashval_t > -pre_expr_d::hash (const value_type *e) > +pre_expr_d::hash (const pre_expr_d *e) > { > switch (e->kind) > { > @@ -547,10 +547,10 @@ typedef struct expr_pred_trans_d : typed_free_remove<expr_pred_trans_d> > hashval_t hashcode; > > /* hash_table support. */ > - typedef expr_pred_trans_d value_type; > - typedef expr_pred_trans_d compare_type; > - static inline hashval_t hash (const value_type *); > - static inline int equal (const value_type *, const compare_type *); > + typedef expr_pred_trans_d *value_type; > + typedef expr_pred_trans_d *compare_type; > + static inline hashval_t hash (const expr_pred_trans_d *); > + static inline int equal (const expr_pred_trans_d *, const expr_pred_trans_d *); > } *expr_pred_trans_t; > typedef const struct expr_pred_trans_d *const_expr_pred_trans_t; > > @@ -561,8 +561,8 @@ expr_pred_trans_d::hash (const expr_pred_trans_d *e) > } > > inline int > -expr_pred_trans_d::equal (const value_type *ve1, > - const compare_type *ve2) > +expr_pred_trans_d::equal (const expr_pred_trans_d *ve1, > + const expr_pred_trans_d *ve2) > { > basic_block b1 = ve1->pred; > basic_block b2 = ve2->pred; > diff --git a/gcc/tree-ssa-reassoc.c b/gcc/tree-ssa-reassoc.c > index 77640e5..ae9d631 100644 > --- a/gcc/tree-ssa-reassoc.c > +++ b/gcc/tree-ssa-reassoc.c > @@ -1061,7 +1061,6 @@ struct oecount_hasher > { > typedef int value_type; > typedef int compare_type; > - typedef int store_values_directly; > static inline hashval_t hash (const value_type &); > static inline bool equal (const value_type &, const compare_type &); > static bool is_deleted (int &v) { return v == 1; } > diff --git a/gcc/tree-ssa-sccvn.c b/gcc/tree-ssa-sccvn.c > index 46ce285..c6a16bc 100644 > --- a/gcc/tree-ssa-sccvn.c > +++ b/gcc/tree-ssa-sccvn.c > @@ -148,16 +148,16 @@ along with GCC; see the file COPYING3. If not see > > struct vn_nary_op_hasher : typed_noop_remove <vn_nary_op_s> > { > - typedef vn_nary_op_s value_type; > - typedef vn_nary_op_s compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef vn_nary_op_s *value_type; > + typedef vn_nary_op_s *compare_type; > + static inline hashval_t hash (const vn_nary_op_s *); > + static inline bool equal (const vn_nary_op_s *, const vn_nary_op_s *); > }; > > /* Return the computed hashcode for nary operation P1. */ > > inline hashval_t > -vn_nary_op_hasher::hash (const value_type *vno1) > +vn_nary_op_hasher::hash (const vn_nary_op_s *vno1) > { > return vno1->hashcode; > } > @@ -166,7 +166,7 @@ vn_nary_op_hasher::hash (const value_type *vno1) > equivalent. */ > > inline bool > -vn_nary_op_hasher::equal (const value_type *vno1, const compare_type *vno2) > +vn_nary_op_hasher::equal (const vn_nary_op_s *vno1, const vn_nary_op_s *vno2) > { > return vn_nary_op_eq (vno1, vno2); > } > @@ -182,17 +182,17 @@ vn_phi_eq (const_vn_phi_t const vp1, const_vn_phi_t const vp2); > > struct vn_phi_hasher > { > - typedef vn_phi_s value_type; > - typedef vn_phi_s compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > - static inline void remove (value_type *); > + typedef vn_phi_s *value_type; > + typedef vn_phi_s *compare_type; > + static inline hashval_t hash (const vn_phi_s *); > + static inline bool equal (const vn_phi_s *, const vn_phi_s *); > + static inline void remove (vn_phi_s *); > }; > > /* Return the computed hashcode for phi operation P1. */ > > inline hashval_t > -vn_phi_hasher::hash (const value_type *vp1) > +vn_phi_hasher::hash (const vn_phi_s *vp1) > { > return vp1->hashcode; > } > @@ -200,7 +200,7 @@ vn_phi_hasher::hash (const value_type *vp1) > /* Compare two phi entries for equality, ignoring VN_TOP arguments. */ > > inline bool > -vn_phi_hasher::equal (const value_type *vp1, const compare_type *vp2) > +vn_phi_hasher::equal (const vn_phi_s *vp1, const vn_phi_s *vp2) > { > return vn_phi_eq (vp1, vp2); > } > @@ -208,7 +208,7 @@ vn_phi_hasher::equal (const value_type *vp1, const compare_type *vp2) > /* Free a phi operation structure VP. */ > > inline void > -vn_phi_hasher::remove (value_type *phi) > +vn_phi_hasher::remove (vn_phi_s *phi) > { > phi->phiargs.release (); > } > @@ -250,29 +250,29 @@ free_reference (vn_reference_s *vr) > > struct vn_reference_hasher > { > - typedef vn_reference_s value_type; > - typedef vn_reference_s compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > - static inline void remove (value_type *); > + typedef vn_reference_s *value_type; > + typedef vn_reference_s *compare_type; > + static inline hashval_t hash (const vn_reference_s *); > + static inline bool equal (const vn_reference_s *, const vn_reference_s *); > + static inline void remove (vn_reference_s *); > }; > > /* Return the hashcode for a given reference operation P1. */ > > inline hashval_t > -vn_reference_hasher::hash (const value_type *vr1) > +vn_reference_hasher::hash (const vn_reference_s *vr1) > { > return vr1->hashcode; > } > > inline bool > -vn_reference_hasher::equal (const value_type *v, const compare_type *c) > +vn_reference_hasher::equal (const vn_reference_s *v, const vn_reference_s *c) > { > return vn_reference_eq (v, c); > } > > inline void > -vn_reference_hasher::remove (value_type *v) > +vn_reference_hasher::remove (vn_reference_s *v) > { > free_reference (v); > } > @@ -298,16 +298,16 @@ typedef struct vn_tables_s > > struct vn_constant_hasher : typed_free_remove <vn_constant_s> > { > - typedef vn_constant_s value_type; > - typedef vn_constant_s compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef vn_constant_s *value_type; > + typedef vn_constant_s *compare_type; > + static inline hashval_t hash (const vn_constant_s *); > + static inline bool equal (const vn_constant_s *, const vn_constant_s *); > }; > > /* Hash table hash function for vn_constant_t. */ > > inline hashval_t > -vn_constant_hasher::hash (const value_type *vc1) > +vn_constant_hasher::hash (const vn_constant_s *vc1) > { > return vc1->hashcode; > } > @@ -315,7 +315,7 @@ vn_constant_hasher::hash (const value_type *vc1) > /* Hash table equality function for vn_constant_t. */ > > inline bool > -vn_constant_hasher::equal (const value_type *vc1, const compare_type *vc2) > +vn_constant_hasher::equal (const vn_constant_s *vc1, const vn_constant_s *vc2) > { > if (vc1->hashcode != vc2->hashcode) > return false; > diff --git a/gcc/tree-ssa-structalias.c b/gcc/tree-ssa-structalias.c > index fd0f535..d6a9f67 100644 > --- a/gcc/tree-ssa-structalias.c > +++ b/gcc/tree-ssa-structalias.c > @@ -1940,16 +1940,17 @@ typedef const struct equiv_class_label *const_equiv_class_label_t; > > struct equiv_class_hasher : typed_free_remove <equiv_class_label> > { > - typedef equiv_class_label value_type; > - typedef equiv_class_label compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef equiv_class_label *value_type; > + typedef equiv_class_label *compare_type; > + static inline hashval_t hash (const equiv_class_label *); > + static inline bool equal (const equiv_class_label *, > + const equiv_class_label *); > }; > > /* Hash function for a equiv_class_label_t */ > > inline hashval_t > -equiv_class_hasher::hash (const value_type *ecl) > +equiv_class_hasher::hash (const equiv_class_label *ecl) > { > return ecl->hashcode; > } > @@ -1957,7 +1958,8 @@ equiv_class_hasher::hash (const value_type *ecl) > /* Equality function for two equiv_class_label_t's. */ > > inline bool > -equiv_class_hasher::equal (const value_type *eql1, const compare_type *eql2) > +equiv_class_hasher::equal (const equiv_class_label *eql1, > + const equiv_class_label *eql2) > { > return (eql1->hashcode == eql2->hashcode > && bitmap_equal_p (eql1->labels, eql2->labels)); > @@ -5963,16 +5965,17 @@ typedef const struct shared_bitmap_info *const_shared_bitmap_info_t; > > struct shared_bitmap_hasher : typed_free_remove <shared_bitmap_info> > { > - typedef shared_bitmap_info value_type; > - typedef shared_bitmap_info compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef shared_bitmap_info *value_type; > + typedef shared_bitmap_info *compare_type; > + static inline hashval_t hash (const shared_bitmap_info *); > + static inline bool equal (const shared_bitmap_info *, > + const shared_bitmap_info *); > }; > > /* Hash function for a shared_bitmap_info_t */ > > inline hashval_t > -shared_bitmap_hasher::hash (const value_type *bi) > +shared_bitmap_hasher::hash (const shared_bitmap_info *bi) > { > return bi->hashcode; > } > @@ -5980,7 +5983,8 @@ shared_bitmap_hasher::hash (const value_type *bi) > /* Equality function for two shared_bitmap_info_t's. */ > > inline bool > -shared_bitmap_hasher::equal (const value_type *sbi1, const compare_type *sbi2) > +shared_bitmap_hasher::equal (const shared_bitmap_info *sbi1, > + const shared_bitmap_info *sbi2) > { > return bitmap_equal_p (sbi1->pt_vars, sbi2->pt_vars); > } > diff --git a/gcc/tree-ssa-tail-merge.c b/gcc/tree-ssa-tail-merge.c > index 2c48cb6..4afe94e 100644 > --- a/gcc/tree-ssa-tail-merge.c > +++ b/gcc/tree-ssa-tail-merge.c > @@ -260,11 +260,11 @@ struct same_succ_def > hashval_t hashval; > > /* hash_table support. */ > - typedef same_succ_def value_type; > - typedef same_succ_def compare_type; > - static inline hashval_t hash (const value_type *); > - static int equal (const value_type *, const compare_type *); > - static void remove (value_type *); > + typedef same_succ_def *value_type; > + typedef same_succ_def *compare_type; > + static inline hashval_t hash (const same_succ_def *); > + static int equal (const same_succ_def *, const same_succ_def *); > + static void remove (same_succ_def *); > }; > typedef struct same_succ_def *same_succ; > typedef const struct same_succ_def *const_same_succ; > @@ -272,7 +272,7 @@ typedef const struct same_succ_def *const_same_succ; > /* hash routine for hash_table support, returns hashval of E. */ > > inline hashval_t > -same_succ_def::hash (const value_type *e) > +same_succ_def::hash (const same_succ_def *e) > { > return e->hashval; > } > @@ -568,7 +568,7 @@ inverse_flags (const_same_succ e1, const_same_succ e2) > /* Compares SAME_SUCCs E1 and E2. */ > > int > -same_succ_def::equal (const value_type *e1, const compare_type *e2) > +same_succ_def::equal (const same_succ_def *e1, const same_succ_def *e2) > { > unsigned int i, first1, first2; > gimple_stmt_iterator gsi1, gsi2; > diff --git a/gcc/tree-ssa-threadupdate.c b/gcc/tree-ssa-threadupdate.c > index 610e807..709b16e 100644 > --- a/gcc/tree-ssa-threadupdate.c > +++ b/gcc/tree-ssa-threadupdate.c > @@ -160,10 +160,10 @@ struct redirection_data : typed_free_remove<redirection_data> > struct el *incoming_edges; > > /* hash_table support. */ > - typedef redirection_data value_type; > - typedef redirection_data compare_type; > - static inline hashval_t hash (const value_type *); > - static inline int equal (const value_type *, const compare_type *); > + typedef redirection_data *value_type; > + typedef redirection_data *compare_type; > + static inline hashval_t hash (const redirection_data *); > + static inline int equal (const redirection_data *, const redirection_data *); > }; > > /* Dump a jump threading path, including annotations about each > @@ -209,7 +209,7 @@ dump_jump_thread_path (FILE *dump_file, vec<jump_thread_edge *> path, > path. So hash on the block index of the final edge in the path. */ > > inline hashval_t > -redirection_data::hash (const value_type *p) > +redirection_data::hash (const redirection_data *p) > { > vec<jump_thread_edge *> *path = p->path; > return path->last ()->e->dest->index; > @@ -218,7 +218,7 @@ redirection_data::hash (const value_type *p) > /* Given two hash table entries, return true if they have the same > jump threading path. */ > inline int > -redirection_data::equal (const value_type *p1, const compare_type *p2) > +redirection_data::equal (const redirection_data *p1, const redirection_data *p2) > { > vec<jump_thread_edge *> *path1 = p1->path; > vec<jump_thread_edge *> *path2 = p2->path; > diff --git a/gcc/tree-vectorizer.c b/gcc/tree-vectorizer.c > index 415bffa..313e936 100644 > --- a/gcc/tree-vectorizer.c > +++ b/gcc/tree-vectorizer.c > @@ -118,20 +118,20 @@ struct simduid_to_vf : typed_free_remove<simduid_to_vf> > int vf; > > /* hash_table support. */ > - typedef simduid_to_vf value_type; > - typedef simduid_to_vf compare_type; > - static inline hashval_t hash (const value_type *); > - static inline int equal (const value_type *, const compare_type *); > + typedef simduid_to_vf *value_type; > + typedef simduid_to_vf *compare_type; > + static inline hashval_t hash (const simduid_to_vf *); > + static inline int equal (const simduid_to_vf *, const simduid_to_vf *); > }; > > inline hashval_t > -simduid_to_vf::hash (const value_type *p) > +simduid_to_vf::hash (const simduid_to_vf *p) > { > return p->simduid; > } > > inline int > -simduid_to_vf::equal (const value_type *p1, const value_type *p2) > +simduid_to_vf::equal (const simduid_to_vf *p1, const simduid_to_vf *p2) > { > return p1->simduid == p2->simduid; > } > @@ -154,20 +154,22 @@ struct simd_array_to_simduid : typed_free_remove<simd_array_to_simduid> > unsigned int simduid; > > /* hash_table support. */ > - typedef simd_array_to_simduid value_type; > - typedef simd_array_to_simduid compare_type; > - static inline hashval_t hash (const value_type *); > - static inline int equal (const value_type *, const compare_type *); > + typedef simd_array_to_simduid *value_type; > + typedef simd_array_to_simduid *compare_type; > + static inline hashval_t hash (const simd_array_to_simduid *); > + static inline int equal (const simd_array_to_simduid *, > + const simd_array_to_simduid *); > }; > > inline hashval_t > -simd_array_to_simduid::hash (const value_type *p) > +simd_array_to_simduid::hash (const simd_array_to_simduid *p) > { > return DECL_UID (p->decl); > } > > inline int > -simd_array_to_simduid::equal (const value_type *p1, const value_type *p2) > +simd_array_to_simduid::equal (const simd_array_to_simduid *p1, > + const simd_array_to_simduid *p2) > { > return p1->decl == p2->decl; > } > diff --git a/gcc/tree-vectorizer.h b/gcc/tree-vectorizer.h > index 66d592d..f22d6cf 100644 > --- a/gcc/tree-vectorizer.h > +++ b/gcc/tree-vectorizer.h > @@ -220,20 +220,20 @@ typedef struct _vect_peel_extended_info > > struct peel_info_hasher : typed_free_remove <_vect_peel_info> > { > - typedef _vect_peel_info value_type; > - typedef _vect_peel_info compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef _vect_peel_info *value_type; > + typedef _vect_peel_info *compare_type; > + static inline hashval_t hash (const _vect_peel_info *); > + static inline bool equal (const _vect_peel_info *, const _vect_peel_info *); > }; > > inline hashval_t > -peel_info_hasher::hash (const value_type *peel_info) > +peel_info_hasher::hash (const _vect_peel_info *peel_info) > { > return (hashval_t) peel_info->npeel; > } > > inline bool > -peel_info_hasher::equal (const value_type *a, const compare_type *b) > +peel_info_hasher::equal (const _vect_peel_info *a, const _vect_peel_info *b) > { > return (a->npeel == b->npeel); > } > diff --git a/gcc/valtrack.h b/gcc/valtrack.h > index 402fef9..b7b53f3 100644 > --- a/gcc/valtrack.h > +++ b/gcc/valtrack.h > @@ -45,33 +45,35 @@ struct dead_debug_global_entry > struct dead_debug_hash_descr > { > /* The hash table contains pointers to entries of this type. */ > - typedef struct dead_debug_global_entry value_type; > - typedef struct dead_debug_global_entry compare_type; > + typedef struct dead_debug_global_entry *value_type; > + typedef struct dead_debug_global_entry *compare_type; > /* Hash on the pseudo number. */ > - static inline hashval_t hash (const value_type *my); > + static inline hashval_t hash (const dead_debug_global_entry *my); > /* Entries are identical if they refer to the same pseudo. */ > - static inline bool equal (const value_type *my, const compare_type *other); > + static inline bool equal (const dead_debug_global_entry *my, > + const dead_debug_global_entry *other); > /* Release entries when they're removed. */ > - static inline void remove (value_type *p); > + static inline void remove (dead_debug_global_entry *p); > }; > > /* Hash on the pseudo number. */ > inline hashval_t > -dead_debug_hash_descr::hash (const value_type *my) > +dead_debug_hash_descr::hash (const dead_debug_global_entry *my) > { > return REGNO (my->reg); > } > > /* Entries are identical if they refer to the same pseudo. */ > inline bool > -dead_debug_hash_descr::equal (const value_type *my, const compare_type *other) > +dead_debug_hash_descr::equal (const dead_debug_global_entry *my, > + const dead_debug_global_entry *other) > { > return my->reg == other->reg; > } > > /* Release entries when they're removed. */ > inline void > -dead_debug_hash_descr::remove (value_type *p) > +dead_debug_hash_descr::remove (dead_debug_global_entry *p) > { > XDELETE (p); > } > diff --git a/gcc/var-tracking.c b/gcc/var-tracking.c > index 18eff20..685fcc38c 100644 > --- a/gcc/var-tracking.c > +++ b/gcc/var-tracking.c > @@ -494,18 +494,18 @@ static void variable_htab_free (void *); > > struct variable_hasher > { > - typedef variable_def value_type; > - typedef void compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > - static inline void remove (value_type *); > + typedef variable_def *value_type; > + typedef void *compare_type; > + static inline hashval_t hash (const variable_def *); > + static inline bool equal (const variable_def *, const void *); > + static inline void remove (variable_def *); > }; > > /* The hash function for variable_htab, computes the hash value > from the declaration of variable X. */ > > inline hashval_t > -variable_hasher::hash (const value_type *v) > +variable_hasher::hash (const variable_def *v) > { > return dv_htab_hash (v->dv); > } > @@ -513,7 +513,7 @@ variable_hasher::hash (const value_type *v) > /* Compare the declaration of variable X with declaration Y. */ > > inline bool > -variable_hasher::equal (const value_type *v, const compare_type *y) > +variable_hasher::equal (const variable_def *v, const void *y) > { > decl_or_value dv = CONST_CAST2 (decl_or_value, const void *, y); > > @@ -523,7 +523,7 @@ variable_hasher::equal (const value_type *v, const compare_type *y) > /* Free the element of VARIABLE_HTAB (its type is struct variable_def). */ > > inline void > -variable_hasher::remove (value_type *var) > +variable_hasher::remove (variable_def *var) > { > variable_htab_free (var); > } > diff --git a/gcc/vtable-verify.c b/gcc/vtable-verify.c > index 22b7b81..8ced835 100644 > --- a/gcc/vtable-verify.c > +++ b/gcc/vtable-verify.c > @@ -268,14 +268,15 @@ vtbl_map_node_registration_insert (struct vtbl_map_node *node, > /* Hashtable functions for vtable_registration hashtables. */ > > inline hashval_t > -registration_hasher::hash (const value_type *p) > +registration_hasher::hash (const vtable_registration *p) > { > const struct vtable_registration *n = (const struct vtable_registration *) p; > return (hashval_t) (DECL_UID (n->vtable_decl)); > } > > inline bool > -registration_hasher::equal (const value_type *p1, const compare_type *p2) > +registration_hasher::equal (const vtable_registration *p1, > + const vtable_registration *p2) > { > const struct vtable_registration *n1 = > (const struct vtable_registration *) p1; > @@ -292,16 +293,16 @@ registration_hasher::equal (const value_type *p1, const compare_type *p2) > > struct vtbl_map_hasher : typed_noop_remove <struct vtbl_map_node> > { > - typedef struct vtbl_map_node value_type; > - typedef struct vtbl_map_node compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef struct vtbl_map_node *value_type; > + typedef struct vtbl_map_node *compare_type; > + static inline hashval_t hash (const vtbl_map_node *); > + static inline bool equal (const vtbl_map_node *, const vtbl_map_node *); > }; > > /* Returns a hash code for P. */ > > inline hashval_t > -vtbl_map_hasher::hash (const value_type *p) > +vtbl_map_hasher::hash (const vtbl_map_node *p) > { > const struct vtbl_map_node n = *((const struct vtbl_map_node *) p); > return (hashval_t) IDENTIFIER_HASH_VALUE (n.class_name); > @@ -310,7 +311,7 @@ vtbl_map_hasher::hash (const value_type *p) > /* Returns nonzero if P1 and P2 are equal. */ > > inline bool > -vtbl_map_hasher::equal (const value_type *p1, const compare_type *p2) > +vtbl_map_hasher::equal (const vtbl_map_node *p1, const vtbl_map_node *p2) > { > const struct vtbl_map_node n1 = *((const struct vtbl_map_node *) p1); > const struct vtbl_map_node n2 = *((const struct vtbl_map_node *) p2); > diff --git a/gcc/vtable-verify.h b/gcc/vtable-verify.h > index b0169ad..6fb2b60 100644 > --- a/gcc/vtable-verify.h > +++ b/gcc/vtable-verify.h > @@ -58,10 +58,11 @@ struct vtable_registration > > struct registration_hasher : typed_noop_remove <struct vtable_registration> > { > - typedef struct vtable_registration value_type; > - typedef struct vtable_registration compare_type; > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + typedef struct vtable_registration *value_type; > + typedef struct vtable_registration *compare_type; > + static inline hashval_t hash (const vtable_registration *); > + static inline bool equal (const vtable_registration *, > + const vtable_registration *); > }; > > typedef hash_table<registration_hasher> register_table_type; > diff --git a/libcc1/plugin.cc b/libcc1/plugin.cc > index c4caf05..74a7ec3 100644 > --- a/libcc1/plugin.cc > +++ b/libcc1/plugin.cc > @@ -113,38 +113,38 @@ struct decl_addr_value > > struct decl_addr_hasher : typed_free_remove<decl_addr_value> > { > - typedef decl_addr_value value_type; > - typedef decl_addr_value compare_type; > + typedef decl_addr_value *value_type; > + typedef decl_addr_value *compare_type; > > - static inline hashval_t hash (const value_type *); > - static inline bool equal (const value_type *, const compare_type *); > + static inline hashval_t hash (const decl_addr_value *); > + static inline bool equal (const decl_addr_value *, const decl_addr_value *); > }; > > inline hashval_t > -decl_addr_hasher::hash (const value_type *e) > +decl_addr_hasher::hash (const decl_addr_value *e) > { > return IDENTIFIER_HASH_VALUE (DECL_NAME (e->decl)); > } > > inline bool > -decl_addr_hasher::equal (const value_type *p1, const compare_type *p2) > +decl_addr_hasher::equal (const decl_addr_value *p1, const decl_addr_value *p2) > { > return p1->decl == p2->decl; > } > > > > -struct string_hasher : typed_noop_remove<char> > +struct string_hasher : typed_noop_remove<const char> > { > - typedef char value_type; > - typedef char compare_type; > + typedef const char *value_type; > + typedef const char *compare_type; > > - static inline hashval_t hash (const value_type *s) > + static inline hashval_t hash (const char *s) > { > return htab_hash_string (s); > } > > - static inline bool equal (const value_type *p1, const value_type *p2) > + static inline bool equal (const char *p1, const char *p2) > { > return strcmp (p1, p2) == 0; > } > @@ -210,7 +210,7 @@ private: > // Add a file name to FILE_NAMES and return the canonical copy. > const char *intern_filename (const char *filename) > { > - char **slot = file_names.find_slot (filename, INSERT); > + const char **slot = file_names.find_slot (filename, INSERT); > if (*slot == NULL) > { > /* The file name must live as long as the line map, which > -- > 2.3.0.80.g18d0fec.dirty >
On Fri, Apr 17, 2015 at 09:29:07AM +0200, Richard Biener wrote: > On Fri, Apr 17, 2015 at 6:38 AM, <tbsaunde+gcc@tbsaunde.org> wrote: > > From: Trevor Saunders <tbsaunde+gcc@tbsaunde.org> > > > > Hi, > > > > Last stage 1 I introduced a second form of hash_table that stored elements of > > value_type in addition to the old form that stored elements of type value_type > > *. That lead to a fair bit of code dupplication in hash_table, but it > > simplified the transition by allowing it to take place one hash table at a > > time. Now I'm switching the rest of the hash_table users to use the new setup, > > and removing supporot for the old one. > > > > this was bootstrapped and regtested on x86_64-unknown-linux-gnu, and I ran make > > all-gcc for the following crosses to check the hash tables they use were > > correctly converted > > arm-linux-androideabi > > i686-apple-darwin > > i686-solaris2.11 > > i686-w64-mingw32 > > ia64-linux > > mips64-linux > > nvptx-elf > > ppc64-linux > > > > Is this ok? > > Ok. committed as r222213 thanks! Trev > > Thanks, > Richard. > > > Trev > > > > gcc/ > > > > * hash-table.h: Remove version of hash_table that stored value_type *. > > * asan.c, attribs.c, bitmap.c, cfg.c, cgraph.h, config/arm/arm.c, > > config/i386/winnt.c, config/ia64/ia64.c, config/mips/mips.c, > > config/sol2.c, coverage.c, cselib.c, dse.c, dwarf2cfi.c, > > dwarf2out.c, except.c, gcse.c, genmatch.c, ggc-common.c, > > gimple-ssa-strength-reduction.c, gimplify.c, haifa-sched.c, > > hard-reg-set.h, hash-map.h, hash-set.h, ipa-devirt.c, ipa-icf.h, > > ipa-profile.c, ira-color.c, ira-costs.c, loop-invariant.c, > > loop-iv.c, loop-unroll.c, lto-streamer.h, plugin.c, postreload-gcse.c, > > reginfo.c, statistics.c, store-motion.c, trans-mem.c, tree-cfg.c, > > tree-eh.c, tree-hasher.h, tree-into-ssa.c, tree-parloops.c, > > tree-sra.c, tree-ssa-coalesce.c, tree-ssa-dom.c, tree-ssa-live.c, > > tree-ssa-loop-im.c, tree-ssa-loop-ivopts.c, tree-ssa-phiopt.c, > > tree-ssa-pre.c, tree-ssa-reassoc.c, tree-ssa-sccvn.c, > > tree-ssa-structalias.c, tree-ssa-tail-merge.c, > > tree-ssa-threadupdate.c, tree-vectorizer.c, tree-vectorizer.h, > > valtrack.h, var-tracking.c, vtable-verify.c, vtable-verify.h: Adjust. > > > > > > libcc1/ > > > > * plugin.cc: Adjust for hash_table changes. > > > > java/ > > > > * jcf-io.c: Adjust for hash_table changes. > > > > lto/ > > > > * lto.c: Adjust for hash_table changes. > > > > objc/ > > > > * objc-act.c: Adjust for hash_table changes. > > > > diff --git a/gcc/asan.c b/gcc/asan.c > > index 9e4a629..7b70ee2 100644 > > --- a/gcc/asan.c > > +++ b/gcc/asan.c > > @@ -407,11 +407,11 @@ asan_mem_ref_get_end (const asan_mem_ref *ref, tree len) > > struct asan_mem_ref_hasher > > : typed_noop_remove <asan_mem_ref> > > { > > - typedef asan_mem_ref value_type; > > - typedef asan_mem_ref compare_type; > > + typedef asan_mem_ref *value_type; > > + typedef asan_mem_ref *compare_type; > > > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + static inline hashval_t hash (const asan_mem_ref *); > > + static inline bool equal (const asan_mem_ref *, const asan_mem_ref *); > > }; > > > > /* Hash a memory reference. */ > > diff --git a/gcc/attribs.c b/gcc/attribs.c > > index c18bff2..7b7e2a9 100644 > > --- a/gcc/attribs.c > > +++ b/gcc/attribs.c > > @@ -67,21 +67,21 @@ substring_hash (const char *str, int l) > > > > struct attribute_hasher : typed_noop_remove <attribute_spec> > > { > > - typedef attribute_spec value_type; > > - typedef substring compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef attribute_spec *value_type; > > + typedef substring *compare_type; > > + static inline hashval_t hash (const attribute_spec *); > > + static inline bool equal (const attribute_spec *, const substring *); > > }; > > > > inline hashval_t > > -attribute_hasher::hash (const value_type *spec) > > +attribute_hasher::hash (const attribute_spec *spec) > > { > > const int l = strlen (spec->name); > > return substring_hash (spec->name, l); > > } > > > > inline bool > > -attribute_hasher::equal (const value_type *spec, const compare_type *str) > > +attribute_hasher::equal (const attribute_spec *spec, const substring *str) > > { > > return (strncmp (spec->name, str->str, str->length) == 0 > > && !spec->name[str->length]); > > diff --git a/gcc/bitmap.c b/gcc/bitmap.c > > index d43a39f..71d5b11 100644 > > --- a/gcc/bitmap.c > > +++ b/gcc/bitmap.c > > @@ -61,20 +61,20 @@ struct loc > > > > struct bitmap_desc_hasher : typed_noop_remove <bitmap_descriptor_d> > > { > > - typedef bitmap_descriptor_d value_type; > > - typedef loc compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef bitmap_descriptor_d *value_type; > > + typedef loc *compare_type; > > + static inline hashval_t hash (const bitmap_descriptor_d *); > > + static inline bool equal (const bitmap_descriptor_d *, const loc *); > > }; > > > > inline hashval_t > > -bitmap_desc_hasher::hash (const value_type *d) > > +bitmap_desc_hasher::hash (const bitmap_descriptor_d *d) > > { > > return htab_hash_pointer (d->file) + d->line; > > } > > > > inline bool > > -bitmap_desc_hasher::equal (const value_type *d, const compare_type *l) > > +bitmap_desc_hasher::equal (const bitmap_descriptor_d *d, const loc *l) > > { > > return d->file == l->file && d->function == l->function && d->line == l->line; > > } > > diff --git a/gcc/cfg.c b/gcc/cfg.c > > index d96be45..3074500 100644 > > --- a/gcc/cfg.c > > +++ b/gcc/cfg.c > > @@ -1039,21 +1039,22 @@ struct htab_bb_copy_original_entry > > > > struct bb_copy_hasher : typed_noop_remove <htab_bb_copy_original_entry> > > { > > - typedef htab_bb_copy_original_entry value_type; > > - typedef htab_bb_copy_original_entry compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *existing, > > - const compare_type * candidate); > > + typedef htab_bb_copy_original_entry *value_type; > > + typedef htab_bb_copy_original_entry *compare_type; > > + static inline hashval_t hash (const htab_bb_copy_original_entry *); > > + static inline bool equal (const htab_bb_copy_original_entry *existing, > > + const htab_bb_copy_original_entry * candidate); > > }; > > > > inline hashval_t > > -bb_copy_hasher::hash (const value_type *data) > > +bb_copy_hasher::hash (const htab_bb_copy_original_entry *data) > > { > > return data->index1; > > } > > > > inline bool > > -bb_copy_hasher::equal (const value_type *data, const compare_type *data2) > > +bb_copy_hasher::equal (const htab_bb_copy_original_entry *data, > > + const htab_bb_copy_original_entry *data2) > > { > > return data->index1 == data2->index1; > > } > > diff --git a/gcc/cgraph.h b/gcc/cgraph.h > > index cf8c7b6..29f65a8 100644 > > --- a/gcc/cgraph.h > > +++ b/gcc/cgraph.h > > @@ -1872,7 +1872,6 @@ struct asmname_hasher > > { > > typedef symtab_node *value_type; > > typedef const_tree compare_type; > > - typedef int store_values_directly; > > > > static hashval_t hash (symtab_node *n); > > static bool equal (symtab_node *n, const_tree t); > > diff --git a/gcc/config/arm/arm.c b/gcc/config/arm/arm.c > > index 0466399..6826c78 100644 > > --- a/gcc/config/arm/arm.c > > +++ b/gcc/config/arm/arm.c > > @@ -4897,21 +4897,21 @@ arm_function_value(const_tree type, const_tree func, > > > > struct libcall_hasher : typed_noop_remove <rtx_def> > > { > > - typedef rtx_def value_type; > > - typedef rtx_def compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > - static inline void remove (value_type *); > > + typedef const rtx_def *value_type; > > + typedef const rtx_def *compare_type; > > + static inline hashval_t hash (const rtx_def *); > > + static inline bool equal (const rtx_def *, const rtx_def *); > > + static inline void remove (rtx_def *); > > }; > > > > inline bool > > -libcall_hasher::equal (const value_type *p1, const compare_type *p2) > > +libcall_hasher::equal (const rtx_def *p1, const rtx_def *p2) > > { > > return rtx_equal_p (p1, p2); > > } > > > > inline hashval_t > > -libcall_hasher::hash (const value_type *p1) > > +libcall_hasher::hash (const rtx_def *p1) > > { > > return hash_rtx (p1, VOIDmode, NULL, NULL, FALSE); > > } > > diff --git a/gcc/config/i386/winnt.c b/gcc/config/i386/winnt.c > > index 14fd253..f61412f 100644 > > --- a/gcc/config/i386/winnt.c > > +++ b/gcc/config/i386/winnt.c > > @@ -738,15 +738,15 @@ i386_pe_record_stub (const char *name) > > > > struct wrapped_symbol_hasher : typed_noop_remove <char> > > { > > - typedef char value_type; > > - typedef char compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > - static inline void remove (value_type *); > > + typedef char *value_type; > > + typedef char *compare_type; > > + static inline hashval_t hash (const char *); > > + static inline bool equal (const char *, const char *); > > + static inline void remove (char *); > > }; > > > > inline hashval_t > > -wrapped_symbol_hasher::hash (const value_type *v) > > +wrapped_symbol_hasher::hash (const char *v) > > { > > return htab_hash_string (v); > > } > > @@ -754,7 +754,7 @@ wrapped_symbol_hasher::hash (const value_type *v) > > /* Hash table equality helper function. */ > > > > inline bool > > -wrapped_symbol_hasher::equal (const value_type *x, const compare_type *y) > > +wrapped_symbol_hasher::equal (const char *x, const char *y) > > { > > return !strcmp (x, y); > > } > > diff --git a/gcc/config/ia64/ia64.c b/gcc/config/ia64/ia64.c > > index 5132d2f..40e6ebe 100644 > > --- a/gcc/config/ia64/ia64.c > > +++ b/gcc/config/ia64/ia64.c > > @@ -8609,16 +8609,16 @@ finish_bundle_states (void) > > > > struct bundle_state_hasher : typed_noop_remove <bundle_state> > > { > > - typedef bundle_state value_type; > > - typedef bundle_state compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef bundle_state *value_type; > > + typedef bundle_state *compare_type; > > + static inline hashval_t hash (const bundle_state *); > > + static inline bool equal (const bundle_state *, const bundle_state *); > > }; > > > > /* The function returns hash of BUNDLE_STATE. */ > > > > inline hashval_t > > -bundle_state_hasher::hash (const value_type *state) > > +bundle_state_hasher::hash (const bundle_state *state) > > { > > unsigned result, i; > > > > @@ -8631,8 +8631,8 @@ bundle_state_hasher::hash (const value_type *state) > > /* The function returns nonzero if the bundle state keys are equal. */ > > > > inline bool > > -bundle_state_hasher::equal (const value_type *state1, > > - const compare_type *state2) > > +bundle_state_hasher::equal (const bundle_state *state1, > > + const bundle_state *state2) > > { > > return (state1->insn_num == state2->insn_num > > && memcmp (state1->dfa_state, state2->dfa_state, > > diff --git a/gcc/config/mips/mips.c b/gcc/config/mips/mips.c > > index 1733457..bf69850 100644 > > --- a/gcc/config/mips/mips.c > > +++ b/gcc/config/mips/mips.c > > @@ -16381,23 +16381,23 @@ mips_hash_base (rtx base) > > > > struct mips_lo_sum_offset_hasher : typed_free_remove <mips_lo_sum_offset> > > { > > - typedef mips_lo_sum_offset value_type; > > - typedef rtx_def compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef mips_lo_sum_offset *value_type; > > + typedef rtx_def *compare_type; > > + static inline hashval_t hash (const mips_lo_sum_offset *); > > + static inline bool equal (const mips_lo_sum_offset *, const rtx_def *); > > }; > > > > /* Hash-table callbacks for mips_lo_sum_offsets. */ > > > > inline hashval_t > > -mips_lo_sum_offset_hasher::hash (const value_type *entry) > > +mips_lo_sum_offset_hasher::hash (const mips_lo_sum_offset *entry) > > { > > return mips_hash_base (entry->base); > > } > > > > inline bool > > -mips_lo_sum_offset_hasher::equal (const value_type *entry, > > - const compare_type *value) > > +mips_lo_sum_offset_hasher::equal (const mips_lo_sum_offset *entry, > > + const rtx_def *value) > > { > > return rtx_equal_p (entry->base, value); > > } > > diff --git a/gcc/config/sol2.c b/gcc/config/sol2.c > > index d256776..d87c7b4 100644 > > --- a/gcc/config/sol2.c > > +++ b/gcc/config/sol2.c > > @@ -183,22 +183,22 @@ typedef struct comdat_entry > > > > struct comdat_entry_hasher : typed_noop_remove <comdat_entry> > > { > > - typedef comdat_entry value_type; > > - typedef comdat_entry compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > - static inline void remove (value_type *); > > + typedef comdat_entry *value_type; > > + typedef comdat_entry *compare_type; > > + static inline hashval_t hash (const comdat_entry *); > > + static inline bool equal (const comdat_entry *, const comdat_entry *); > > + static inline void remove (comdat_entry *); > > }; > > > > inline hashval_t > > -comdat_entry_hasher::hash (const value_type *entry) > > +comdat_entry_hasher::hash (const comdat_entry *entry) > > { > > return htab_hash_string (entry->sig); > > } > > > > inline bool > > -comdat_entry_hasher::equal (const value_type *entry1, > > - const compare_type *entry2) > > +comdat_entry_hasher::equal (const comdat_entry *entry1, > > + const comdat_entry *entry2) > > { > > return strcmp (entry1->sig, entry2->sig) == 0; > > } > > diff --git a/gcc/coverage.c b/gcc/coverage.c > > index 661e441..e1d81ff 100644 > > --- a/gcc/coverage.c > > +++ b/gcc/coverage.c > > @@ -114,11 +114,11 @@ typedef struct counts_entry > > struct gcov_ctr_summary summary; > > > > /* hash_table support. */ > > - typedef counts_entry value_type; > > - typedef counts_entry compare_type; > > - static inline hashval_t hash (const value_type *); > > - static int equal (const value_type *, const compare_type *); > > - static void remove (value_type *); > > + typedef counts_entry *value_type; > > + typedef counts_entry *compare_type; > > + static inline hashval_t hash (const counts_entry *); > > + static int equal (const counts_entry *, const counts_entry *); > > + static void remove (counts_entry *); > > } counts_entry_t; > > > > static GTY(()) struct coverage_data *functions_head = 0; > > @@ -197,20 +197,19 @@ get_gcov_unsigned_t (void) > > } > > > > inline hashval_t > > -counts_entry::hash (const value_type *entry) > > +counts_entry::hash (const counts_entry *entry) > > { > > return entry->ident * GCOV_COUNTERS + entry->ctr; > > } > > > > inline int > > -counts_entry::equal (const value_type *entry1, > > - const compare_type *entry2) > > +counts_entry::equal (const counts_entry *entry1, const counts_entry *entry2) > > { > > return entry1->ident == entry2->ident && entry1->ctr == entry2->ctr; > > } > > > > inline void > > -counts_entry::remove (value_type *entry) > > +counts_entry::remove (counts_entry *entry) > > { > > free (entry->counts); > > free (entry); > > diff --git a/gcc/cselib.c b/gcc/cselib.c > > index d6ccbfb..30845ed 100644 > > --- a/gcc/cselib.c > > +++ b/gcc/cselib.c > > @@ -102,8 +102,8 @@ static rtx cselib_expand_value_rtx_1 (rtx, struct expand_value_data *, int); > > > > struct cselib_hasher : typed_noop_remove <cselib_val> > > { > > - typedef cselib_val value_type; > > - struct compare_type { > > + typedef cselib_val *value_type; > > + struct key { > > /* The rtx value and its mode (needed separately for constant > > integers). */ > > machine_mode mode; > > @@ -111,8 +111,9 @@ struct cselib_hasher : typed_noop_remove <cselib_val> > > /* The mode of the contaning MEM, if any, otherwise VOIDmode. */ > > machine_mode memmode; > > }; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef key *compare_type; > > + static inline hashval_t hash (const cselib_val *); > > + static inline bool equal (const cselib_val *, const key *); > > }; > > > > /* The hash function for our hash table. The value is always computed with > > @@ -120,7 +121,7 @@ struct cselib_hasher : typed_noop_remove <cselib_val> > > hash value from a cselib_val structure. */ > > > > inline hashval_t > > -cselib_hasher::hash (const value_type *v) > > +cselib_hasher::hash (const cselib_val *v) > > { > > return v->hash; > > } > > @@ -131,7 +132,7 @@ cselib_hasher::hash (const value_type *v) > > CONST of an appropriate mode. */ > > > > inline bool > > -cselib_hasher::equal (const value_type *v, const compare_type *x_arg) > > +cselib_hasher::equal (const cselib_val *v, const key *x_arg) > > { > > struct elt_loc_list *l; > > rtx x = x_arg->x; > > @@ -507,7 +508,7 @@ preserve_constants_and_equivs (cselib_val **x, void *info ATTRIBUTE_UNUSED) > > > > if (invariant_or_equiv_p (v)) > > { > > - cselib_hasher::compare_type lookup = { > > + cselib_hasher::key lookup = { > > GET_MODE (v->val_rtx), v->val_rtx, VOIDmode > > }; > > cselib_val **slot > > @@ -592,7 +593,7 @@ cselib_find_slot (machine_mode mode, rtx x, hashval_t hash, > > enum insert_option insert, machine_mode memmode) > > { > > cselib_val **slot = NULL; > > - cselib_hasher::compare_type lookup = { mode, x, memmode }; > > + cselib_hasher::key lookup = { mode, x, memmode }; > > if (cselib_preserve_constants) > > slot = cselib_preserved_hash_table->find_slot_with_hash (&lookup, hash, > > NO_INSERT); > > diff --git a/gcc/dse.c b/gcc/dse.c > > index 2bb20d7..603cdbd 100644 > > --- a/gcc/dse.c > > +++ b/gcc/dse.c > > @@ -667,21 +667,21 @@ clear_alias_set_lookup (alias_set_type alias_set) > > > > struct invariant_group_base_hasher : typed_noop_remove <group_info> > > { > > - typedef group_info value_type; > > - typedef group_info compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef group_info *value_type; > > + typedef group_info *compare_type; > > + static inline hashval_t hash (const group_info *); > > + static inline bool equal (const group_info *, const group_info *); > > }; > > > > inline bool > > -invariant_group_base_hasher::equal (const value_type *gi1, > > - const compare_type *gi2) > > +invariant_group_base_hasher::equal (const group_info *gi1, > > + const group_info *gi2) > > { > > return rtx_equal_p (gi1->rtx_base, gi2->rtx_base); > > } > > > > inline hashval_t > > -invariant_group_base_hasher::hash (const value_type *gi) > > +invariant_group_base_hasher::hash (const group_info *gi) > > { > > int do_not_record; > > return hash_rtx (gi->rtx_base, Pmode, &do_not_record, NULL, false); > > diff --git a/gcc/dwarf2cfi.c b/gcc/dwarf2cfi.c > > index ec2acc9..2469c25 100644 > > --- a/gcc/dwarf2cfi.c > > +++ b/gcc/dwarf2cfi.c > > @@ -182,20 +182,20 @@ typedef dw_trace_info *dw_trace_info_ref; > > > > struct trace_info_hasher : typed_noop_remove <dw_trace_info> > > { > > - typedef dw_trace_info value_type; > > - typedef dw_trace_info compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef dw_trace_info *value_type; > > + typedef dw_trace_info *compare_type; > > + static inline hashval_t hash (const dw_trace_info *); > > + static inline bool equal (const dw_trace_info *, const dw_trace_info *); > > }; > > > > inline hashval_t > > -trace_info_hasher::hash (const value_type *ti) > > +trace_info_hasher::hash (const dw_trace_info *ti) > > { > > return INSN_UID (ti->head); > > } > > > > inline bool > > -trace_info_hasher::equal (const value_type *a, const compare_type *b) > > +trace_info_hasher::equal (const dw_trace_info *a, const dw_trace_info *b) > > { > > return a->head == b->head; > > } > > diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c > > index 6c8e51f..2c33fd5 100644 > > --- a/gcc/dwarf2out.c > > +++ b/gcc/dwarf2out.c > > @@ -6865,28 +6865,28 @@ struct cu_hash_table_entry > > > > struct cu_hash_table_entry_hasher > > { > > - typedef cu_hash_table_entry value_type; > > - typedef die_struct compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > - static inline void remove (value_type *); > > + typedef cu_hash_table_entry *value_type; > > + typedef die_struct *compare_type; > > + static inline hashval_t hash (const cu_hash_table_entry *); > > + static inline bool equal (const cu_hash_table_entry *, const die_struct *); > > + static inline void remove (cu_hash_table_entry *); > > }; > > > > inline hashval_t > > -cu_hash_table_entry_hasher::hash (const value_type *entry) > > +cu_hash_table_entry_hasher::hash (const cu_hash_table_entry *entry) > > { > > return htab_hash_string (entry->cu->die_id.die_symbol); > > } > > > > inline bool > > -cu_hash_table_entry_hasher::equal (const value_type *entry1, > > - const compare_type *entry2) > > +cu_hash_table_entry_hasher::equal (const cu_hash_table_entry *entry1, > > + const die_struct *entry2) > > { > > return !strcmp (entry1->cu->die_id.die_symbol, entry2->die_id.die_symbol); > > } > > > > inline void > > -cu_hash_table_entry_hasher::remove (value_type *entry) > > +cu_hash_table_entry_hasher::remove (cu_hash_table_entry *entry) > > { > > struct cu_hash_table_entry *next; > > > > @@ -7202,21 +7202,21 @@ struct decl_table_entry > > > > struct decl_table_entry_hasher : typed_free_remove <decl_table_entry> > > { > > - typedef decl_table_entry value_type; > > - typedef die_struct compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef decl_table_entry *value_type; > > + typedef die_struct *compare_type; > > + static inline hashval_t hash (const decl_table_entry *); > > + static inline bool equal (const decl_table_entry *, const die_struct *); > > }; > > > > inline hashval_t > > -decl_table_entry_hasher::hash (const value_type *entry) > > +decl_table_entry_hasher::hash (const decl_table_entry *entry) > > { > > return htab_hash_pointer (entry->orig); > > } > > > > inline bool > > -decl_table_entry_hasher::equal (const value_type *entry1, > > - const compare_type *entry2) > > +decl_table_entry_hasher::equal (const decl_table_entry *entry1, > > + const die_struct *entry2) > > { > > return entry1->orig == entry2; > > } > > @@ -7744,14 +7744,14 @@ struct external_ref > > > > struct external_ref_hasher : typed_free_remove <external_ref> > > { > > - typedef external_ref value_type; > > - typedef external_ref compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef external_ref *value_type; > > + typedef external_ref *compare_type; > > + static inline hashval_t hash (const external_ref *); > > + static inline bool equal (const external_ref *, const external_ref *); > > }; > > > > inline hashval_t > > -external_ref_hasher::hash (const value_type *r) > > +external_ref_hasher::hash (const external_ref *r) > > { > > dw_die_ref die = r->type; > > hashval_t h = 0; > > @@ -7772,7 +7772,7 @@ external_ref_hasher::hash (const value_type *r) > > } > > > > inline bool > > -external_ref_hasher::equal (const value_type *r1, const compare_type *r2) > > +external_ref_hasher::equal (const external_ref *r1, const external_ref *r2) > > { > > return r1->type == r2->type; > > } > > @@ -22224,21 +22224,21 @@ dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED, > > > > struct macinfo_entry_hasher : typed_noop_remove <macinfo_entry> > > { > > - typedef macinfo_entry value_type; > > - typedef macinfo_entry compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef macinfo_entry *value_type; > > + typedef macinfo_entry *compare_type; > > + static inline hashval_t hash (const macinfo_entry *); > > + static inline bool equal (const macinfo_entry *, const macinfo_entry *); > > }; > > > > inline hashval_t > > -macinfo_entry_hasher::hash (const value_type *entry) > > +macinfo_entry_hasher::hash (const macinfo_entry *entry) > > { > > return htab_hash_string (entry->info); > > } > > > > inline bool > > -macinfo_entry_hasher::equal (const value_type *entry1, > > - const compare_type *entry2) > > +macinfo_entry_hasher::equal (const macinfo_entry *entry1, > > + const macinfo_entry *entry2) > > { > > return !strcmp (entry1->info, entry2->info); > > } > > @@ -23302,14 +23302,14 @@ file_table_relative_p (dwarf_file_data **slot, bool *p) > > > > struct comdat_type_hasher : typed_noop_remove <comdat_type_node> > > { > > - typedef comdat_type_node value_type; > > - typedef comdat_type_node compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef comdat_type_node *value_type; > > + typedef comdat_type_node *compare_type; > > + static inline hashval_t hash (const comdat_type_node *); > > + static inline bool equal (const comdat_type_node *, const comdat_type_node *); > > }; > > > > inline hashval_t > > -comdat_type_hasher::hash (const value_type *type_node) > > +comdat_type_hasher::hash (const comdat_type_node *type_node) > > { > > hashval_t h; > > memcpy (&h, type_node->signature, sizeof (h)); > > @@ -23317,8 +23317,8 @@ comdat_type_hasher::hash (const value_type *type_node) > > } > > > > inline bool > > -comdat_type_hasher::equal (const value_type *type_node_1, > > - const compare_type *type_node_2) > > +comdat_type_hasher::equal (const comdat_type_node *type_node_1, > > + const comdat_type_node *type_node_2) > > { > > return (! memcmp (type_node_1->signature, type_node_2->signature, > > DWARF_TYPE_SIGNATURE_SIZE)); > > @@ -24405,16 +24405,17 @@ compare_locs (dw_loc_descr_ref x, dw_loc_descr_ref y) > > > > struct loc_list_hasher : typed_noop_remove <dw_loc_list_struct> > > { > > - typedef dw_loc_list_struct value_type; > > - typedef dw_loc_list_struct compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef dw_loc_list_struct *value_type; > > + typedef dw_loc_list_struct *compare_type; > > + static inline hashval_t hash (const dw_loc_list_struct *); > > + static inline bool equal (const dw_loc_list_struct *, > > + const dw_loc_list_struct *); > > }; > > > > /* Return precomputed hash of location list X. */ > > > > inline hashval_t > > -loc_list_hasher::hash (const value_type *x) > > +loc_list_hasher::hash (const dw_loc_list_struct *x) > > { > > return x->hash; > > } > > @@ -24422,7 +24423,8 @@ loc_list_hasher::hash (const value_type *x) > > /* Return true if location lists A and B are the same. */ > > > > inline bool > > -loc_list_hasher::equal (const value_type *a, const compare_type *b) > > +loc_list_hasher::equal (const dw_loc_list_struct *a, > > + const dw_loc_list_struct *b) > > { > > if (a == b) > > return 1; > > diff --git a/gcc/except.c b/gcc/except.c > > index 833ec21..f85e55a 100644 > > --- a/gcc/except.c > > +++ b/gcc/except.c > > @@ -227,20 +227,21 @@ struct action_record > > > > struct action_record_hasher : typed_free_remove <action_record> > > { > > - typedef action_record value_type; > > - typedef action_record compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef action_record *value_type; > > + typedef action_record *compare_type; > > + static inline hashval_t hash (const action_record *); > > + static inline bool equal (const action_record *, const action_record *); > > }; > > > > inline hashval_t > > -action_record_hasher::hash (const value_type *entry) > > +action_record_hasher::hash (const action_record *entry) > > { > > return entry->next * 1009 + entry->filter; > > } > > > > inline bool > > -action_record_hasher::equal (const value_type *entry, const compare_type *data) > > +action_record_hasher::equal (const action_record *entry, > > + const action_record *data) > > { > > return entry->filter == data->filter && entry->next == data->next; > > } > > @@ -742,23 +743,23 @@ struct ttypes_filter { > > > > struct ttypes_filter_hasher : typed_free_remove <ttypes_filter> > > { > > - typedef ttypes_filter value_type; > > - typedef tree_node compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef ttypes_filter *value_type; > > + typedef tree_node *compare_type; > > + static inline hashval_t hash (const ttypes_filter *); > > + static inline bool equal (const ttypes_filter *, const tree_node *); > > }; > > > > /* Compare ENTRY (a ttypes_filter entry in the hash table) with DATA > > (a tree) for a @TTypes type node we are thinking about adding. */ > > > > inline bool > > -ttypes_filter_hasher::equal (const value_type *entry, const compare_type *data) > > +ttypes_filter_hasher::equal (const ttypes_filter *entry, const tree_node *data) > > { > > return entry->t == data; > > } > > > > inline hashval_t > > -ttypes_filter_hasher::hash (const value_type *entry) > > +ttypes_filter_hasher::hash (const ttypes_filter *entry) > > { > > return TREE_HASH (entry->t); > > } > > @@ -770,10 +771,10 @@ typedef hash_table<ttypes_filter_hasher> ttypes_hash_type; > > > > struct ehspec_hasher : typed_free_remove <ttypes_filter> > > { > > - typedef ttypes_filter value_type; > > - typedef ttypes_filter compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef ttypes_filter *value_type; > > + typedef ttypes_filter *compare_type; > > + static inline hashval_t hash (const ttypes_filter *); > > + static inline bool equal (const ttypes_filter *, const ttypes_filter *); > > }; > > > > /* Compare ENTRY with DATA (both struct ttypes_filter) for a @TTypes > > @@ -782,7 +783,7 @@ struct ehspec_hasher : typed_free_remove <ttypes_filter> > > should put these in some canonical order. */ > > > > inline bool > > -ehspec_hasher::equal (const value_type *entry, const compare_type *data) > > +ehspec_hasher::equal (const ttypes_filter *entry, const ttypes_filter *data) > > { > > return type_list_equal (entry->t, data->t); > > } > > @@ -790,7 +791,7 @@ ehspec_hasher::equal (const value_type *entry, const compare_type *data) > > /* Hash function for exception specification lists. */ > > > > inline hashval_t > > -ehspec_hasher::hash (const value_type *entry) > > +ehspec_hasher::hash (const ttypes_filter *entry) > > { > > hashval_t h = 0; > > tree list; > > diff --git a/gcc/gcse.c b/gcc/gcse.c > > index 37aac6a..4be3f36 100644 > > --- a/gcc/gcse.c > > +++ b/gcc/gcse.c > > @@ -388,15 +388,15 @@ static struct ls_expr * pre_ldst_mems = NULL; > > > > struct pre_ldst_expr_hasher : typed_noop_remove <ls_expr> > > { > > - typedef ls_expr value_type; > > + typedef ls_expr *value_type; > > typedef value_type compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + static inline hashval_t hash (const ls_expr *); > > + static inline bool equal (const ls_expr *, const ls_expr *); > > }; > > > > /* Hashtable helpers. */ > > inline hashval_t > > -pre_ldst_expr_hasher::hash (const value_type *x) > > +pre_ldst_expr_hasher::hash (const ls_expr *x) > > { > > int do_not_record_p = 0; > > return > > @@ -406,8 +406,8 @@ pre_ldst_expr_hasher::hash (const value_type *x) > > static int expr_equiv_p (const_rtx, const_rtx); > > > > inline bool > > -pre_ldst_expr_hasher::equal (const value_type *ptr1, > > - const compare_type *ptr2) > > +pre_ldst_expr_hasher::equal (const ls_expr *ptr1, > > + const ls_expr *ptr2) > > { > > return expr_equiv_p (ptr1->pattern, ptr2->pattern); > > } > > diff --git a/gcc/genmatch.c b/gcc/genmatch.c > > index 560a371..fbd12a5 100644 > > --- a/gcc/genmatch.c > > +++ b/gcc/genmatch.c > > @@ -190,21 +190,21 @@ struct id_base : typed_noop_remove<id_base> > > const char *id; > > > > /* hash_table support. */ > > - typedef id_base value_type; > > - typedef id_base compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline int equal (const value_type *, const compare_type *); > > + typedef id_base *value_type; > > + typedef id_base *compare_type; > > + static inline hashval_t hash (const id_base *); > > + static inline int equal (const id_base *, const id_base *); > > }; > > > > inline hashval_t > > -id_base::hash (const value_type *op) > > +id_base::hash (const id_base *op) > > { > > return op->hashval; > > } > > > > inline int > > -id_base::equal (const value_type *op1, > > - const compare_type *op2) > > +id_base::equal (const id_base *op1, > > + const id_base *op2) > > { > > return (op1->hashval == op2->hashval > > && strcmp (op1->id, op2->id) == 0); > > diff --git a/gcc/ggc-common.c b/gcc/ggc-common.c > > index 03fbe7d..eff326a 100644 > > --- a/gcc/ggc-common.c > > +++ b/gcc/ggc-common.c > > @@ -242,20 +242,20 @@ struct ptr_data > > > > struct saving_hasher : typed_free_remove <ptr_data> > > { > > - typedef ptr_data value_type; > > - typedef void compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef ptr_data *value_type; > > + typedef void *compare_type; > > + static inline hashval_t hash (const ptr_data *); > > + static inline bool equal (const ptr_data *, const void *); > > }; > > > > inline hashval_t > > -saving_hasher::hash (const value_type *p) > > +saving_hasher::hash (const ptr_data *p) > > { > > return POINTER_HASH (p->obj); > > } > > > > inline bool > > -saving_hasher::equal (const value_type *p1, const compare_type *p2) > > +saving_hasher::equal (const ptr_data *p1, const void *p2) > > { > > return p1->obj == p2; > > } > > @@ -847,20 +847,22 @@ struct ggc_loc_descriptor > > > > struct ggc_loc_desc_hasher : typed_noop_remove <ggc_loc_descriptor> > > { > > - typedef ggc_loc_descriptor value_type; > > - typedef ggc_loc_descriptor compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef ggc_loc_descriptor *value_type; > > + typedef ggc_loc_descriptor *compare_type; > > + static inline hashval_t hash (const ggc_loc_descriptor *); > > + static inline bool equal (const ggc_loc_descriptor *, > > + const ggc_loc_descriptor *); > > }; > > > > inline hashval_t > > -ggc_loc_desc_hasher::hash (const value_type *d) > > +ggc_loc_desc_hasher::hash (const ggc_loc_descriptor *d) > > { > > return htab_hash_pointer (d->function) | d->line; > > } > > > > inline bool > > -ggc_loc_desc_hasher::equal (const value_type *d, const compare_type *d2) > > +ggc_loc_desc_hasher::equal (const ggc_loc_descriptor *d, > > + const ggc_loc_descriptor *d2) > > { > > return (d->file == d2->file && d->line == d2->line > > && d->function == d2->function); > > @@ -880,20 +882,20 @@ struct ggc_ptr_hash_entry > > > > struct ptr_hash_hasher : typed_noop_remove <ggc_ptr_hash_entry> > > { > > - typedef ggc_ptr_hash_entry value_type; > > - typedef void compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef ggc_ptr_hash_entry *value_type; > > + typedef void *compare_type; > > + static inline hashval_t hash (const ggc_ptr_hash_entry *); > > + static inline bool equal (const ggc_ptr_hash_entry *, const void *); > > }; > > > > inline hashval_t > > -ptr_hash_hasher::hash (const value_type *d) > > +ptr_hash_hasher::hash (const ggc_ptr_hash_entry *d) > > { > > return htab_hash_pointer (d->ptr); > > } > > > > inline bool > > -ptr_hash_hasher::equal (const value_type *p, const compare_type *p2) > > +ptr_hash_hasher::equal (const ggc_ptr_hash_entry *p, const void *p2) > > { > > return (p->ptr == p2); > > } > > diff --git a/gcc/gimple-ssa-strength-reduction.c b/gcc/gimple-ssa-strength-reduction.c > > index 5b84bbe..afd3215 100644 > > --- a/gcc/gimple-ssa-strength-reduction.c > > +++ b/gcc/gimple-ssa-strength-reduction.c > > @@ -438,21 +438,21 @@ lookup_cand (cand_idx idx) > > > > struct cand_chain_hasher : typed_noop_remove <cand_chain> > > { > > - typedef cand_chain value_type; > > - typedef cand_chain compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef cand_chain *value_type; > > + typedef cand_chain *compare_type; > > + static inline hashval_t hash (const cand_chain *); > > + static inline bool equal (const cand_chain *, const cand_chain *); > > }; > > > > inline hashval_t > > -cand_chain_hasher::hash (const value_type *p) > > +cand_chain_hasher::hash (const cand_chain *p) > > { > > tree base_expr = p->base_expr; > > return iterative_hash_expr (base_expr, 0); > > } > > > > inline bool > > -cand_chain_hasher::equal (const value_type *chain1, const compare_type *chain2) > > +cand_chain_hasher::equal (const cand_chain *chain1, const cand_chain *chain2) > > { > > return operand_equal_p (chain1->base_expr, chain2->base_expr, 0); > > } > > diff --git a/gcc/gimplify.c b/gcc/gimplify.c > > index ff0a225..a52455d 100644 > > --- a/gcc/gimplify.c > > +++ b/gcc/gimplify.c > > @@ -136,10 +136,10 @@ enum omp_region_type > > > > struct gimplify_hasher : typed_free_remove <elt_t> > > { > > - typedef elt_t value_type; > > - typedef elt_t compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef elt_t *value_type; > > + typedef elt_t *compare_type; > > + static inline hashval_t hash (const elt_t *); > > + static inline bool equal (const elt_t *, const elt_t *); > > }; > > > > struct gimplify_ctx > > @@ -9384,14 +9384,14 @@ gimplify_assign (tree dst, tree src, gimple_seq *seq_p) > > } > > > > inline hashval_t > > -gimplify_hasher::hash (const value_type *p) > > +gimplify_hasher::hash (const elt_t *p) > > { > > tree t = p->val; > > return iterative_hash_expr (t, 0); > > } > > > > inline bool > > -gimplify_hasher::equal (const value_type *p1, const compare_type *p2) > > +gimplify_hasher::equal (const elt_t *p1, const elt_t *p2) > > { > > tree t1 = p1->val; > > tree t2 = p2->val; > > diff --git a/gcc/haifa-sched.c b/gcc/haifa-sched.c > > index ad2450b..96c038f 100644 > > --- a/gcc/haifa-sched.c > > +++ b/gcc/haifa-sched.c > > @@ -621,16 +621,16 @@ struct delay_pair > > > > struct delay_i1_hasher : typed_noop_remove <delay_pair> > > { > > - typedef delay_pair value_type; > > - typedef void compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef delay_pair *value_type; > > + typedef void *compare_type; > > + static inline hashval_t hash (const delay_pair *); > > + static inline bool equal (const delay_pair *, const void *); > > }; > > > > /* Returns a hash value for X, based on hashing just I1. */ > > > > inline hashval_t > > -delay_i1_hasher::hash (const value_type *x) > > +delay_i1_hasher::hash (const delay_pair *x) > > { > > return htab_hash_pointer (x->i1); > > } > > @@ -638,23 +638,23 @@ delay_i1_hasher::hash (const value_type *x) > > /* Return true if I1 of pair X is the same as that of pair Y. */ > > > > inline bool > > -delay_i1_hasher::equal (const value_type *x, const compare_type *y) > > +delay_i1_hasher::equal (const delay_pair *x, const void *y) > > { > > return x->i1 == y; > > } > > > > struct delay_i2_hasher : typed_free_remove <delay_pair> > > { > > - typedef delay_pair value_type; > > - typedef void compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef delay_pair *value_type; > > + typedef void *compare_type; > > + static inline hashval_t hash (const delay_pair *); > > + static inline bool equal (const delay_pair *, const void *); > > }; > > > > /* Returns a hash value for X, based on hashing just I2. */ > > > > inline hashval_t > > -delay_i2_hasher::hash (const value_type *x) > > +delay_i2_hasher::hash (const delay_pair *x) > > { > > return htab_hash_pointer (x->i2); > > } > > @@ -662,7 +662,7 @@ delay_i2_hasher::hash (const value_type *x) > > /* Return true if I2 of pair X is the same as that of pair Y. */ > > > > inline bool > > -delay_i2_hasher::equal (const value_type *x, const compare_type *y) > > +delay_i2_hasher::equal (const delay_pair *x, const void *y) > > { > > return x->i2 == y; > > } > > diff --git a/gcc/hard-reg-set.h b/gcc/hard-reg-set.h > > index d1a6e51..89971d7 100644 > > --- a/gcc/hard-reg-set.h > > +++ b/gcc/hard-reg-set.h > > @@ -615,7 +615,17 @@ hard_reg_set_iter_next (hard_reg_set_iterator *iter, unsigned *regno) > > > > extern char global_regs[FIRST_PSEUDO_REGISTER]; > > > > -struct simplifiable_subregs_hasher; > > +struct simplifiable_subreg; > > +struct subreg_shape; > > + > > +struct simplifiable_subregs_hasher : typed_noop_remove <simplifiable_subreg> > > +{ > > + typedef simplifiable_subreg *value_type; > > + typedef const subreg_shape *compare_type; > > + > > + static inline hashval_t hash (const simplifiable_subreg *); > > + static inline bool equal (const simplifiable_subreg *, const subreg_shape *); > > +}; > > > > struct target_hard_regs { > > void finalize (); > > diff --git a/gcc/hash-map.h b/gcc/hash-map.h > > index e1dea91..4cca702 100644 > > --- a/gcc/hash-map.h > > +++ b/gcc/hash-map.h > > @@ -114,7 +114,6 @@ class GTY((user)) hash_map > > > > typedef hash_entry value_type; > > typedef Key compare_type; > > - typedef int store_values_directly; > > > > static hashval_t hash (const hash_entry &e) > > { > > diff --git a/gcc/hash-set.h b/gcc/hash-set.h > > index c1e8872..9065451 100644 > > --- a/gcc/hash-set.h > > +++ b/gcc/hash-set.h > > @@ -112,7 +112,6 @@ class hash_set > > > > typedef hash_entry value_type; > > typedef Key compare_type; > > - typedef int store_values_directly; > > > > static hashval_t hash (const hash_entry &e) > > { > > diff --git a/gcc/hash-table.h b/gcc/hash-table.h > > index 447eaff..f6375d1 100644 > > --- a/gcc/hash-table.h > > +++ b/gcc/hash-table.h > > @@ -278,7 +278,6 @@ struct pointer_hash : typed_noop_remove <Type> > > { > > typedef Type *value_type; > > typedef Type *compare_type; > > - typedef int store_values_directly; > > > > static inline hashval_t hash (const value_type &); > > > > @@ -310,7 +309,6 @@ struct ggc_hasher > > { > > typedef T value_type; > > typedef T compare_type; > > - typedef int store_values_directly; > > > > static void remove (T) {} > > > > @@ -342,7 +340,6 @@ struct ggc_cache_hasher > > { > > typedef T value_type; > > typedef T compare_type; > > - typedef int store_values_directly; > > > > static void remove (T &) {} > > > > @@ -438,26 +435,6 @@ hash_table_mod2 (hashval_t hash, unsigned int index) > > return 1 + mul_mod (hash, p->prime - 2, p->inv_m2, p->shift); > > } > > > > -/* The below is some template meta programming to decide if we should use the > > - hash table partial specialization that directly stores value_type instead of > > - pointers to value_type. If the Descriptor type defines the type > > - Descriptor::store_values_directly then values are stored directly otherwise > > - pointers to them are stored. */ > > -template<typename T> struct notype { typedef void type; }; > > - > > -template<typename T, typename = void> > > -struct storage_tester > > -{ > > - static const bool value = false; > > -}; > > - > > -template<typename T> > > -struct storage_tester<T, typename notype<typename > > - T::store_values_directly>::type> > > -{ > > - static const bool value = true; > > -}; > > - > > template<typename Traits> > > struct has_is_deleted > > { > > @@ -576,9 +553,7 @@ struct mark_empty_helper<Type *, Traits, false> > > > > /* User-facing hash table type. > > > > - The table stores elements of type Descriptor::value_type, or pointers to > > - objects of type value_type if the descriptor does not define the type > > - store_values_directly. > > + The table stores elements of type Descriptor::value_type. > > > > It hashes values with the hash member function. > > The table currently works with relatively weak hash functions. > > @@ -601,518 +576,9 @@ struct mark_empty_helper<Type *, Traits, false> > > > > */ > > template <typename Descriptor, > > - template<typename Type> class Allocator= xcallocator, > > - bool Storage = storage_tester<Descriptor>::value> > > + template<typename Type> class Allocator = xcallocator> > > class hash_table > > { > > -}; > > - > > -template <typename Descriptor, > > - template<typename Type> class Allocator> > > -class hash_table<Descriptor, Allocator, false> > > -{ > > - typedef typename Descriptor::value_type value_type; > > - typedef typename Descriptor::compare_type compare_type; > > - > > -public: > > - hash_table (size_t CXX_MEM_STAT_INFO); > > - ~hash_table (); > > - > > - /* Current size (in entries) of the hash table. */ > > - size_t size () const { return m_size; } > > - > > - /* Return the current number of elements in this hash table. */ > > - size_t elements () const { return m_n_elements - m_n_deleted; } > > - > > - /* Return the current number of elements in this hash table. */ > > - size_t elements_with_deleted () const { return m_n_elements; } > > - > > - /* This function clears all entries in the given hash table. */ > > - void empty (); > > - > > - /* This function clears a specified SLOT in a hash table. It is > > - useful when you've already done the lookup and don't want to do it > > - again. */ > > - > > - void clear_slot (value_type **); > > - > > - /* This function searches for a hash table entry equal to the given > > - COMPARABLE element starting with the given HASH value. It cannot > > - be used to insert or delete an element. */ > > - value_type *find_with_hash (const compare_type *, hashval_t); > > - > > -/* Like find_slot_with_hash, but compute the hash value from the element. */ > > - value_type *find (const value_type *value) > > - { > > - return find_with_hash (value, Descriptor::hash (value)); > > - } > > - > > - value_type **find_slot (const value_type *value, insert_option insert) > > - { > > - return find_slot_with_hash (value, Descriptor::hash (value), insert); > > - } > > - > > - /* This function searches for a hash table slot containing an entry > > - equal to the given COMPARABLE element and starting with the given > > - HASH. To delete an entry, call this with insert=NO_INSERT, then > > - call clear_slot on the slot returned (possibly after doing some > > - checks). To insert an entry, call this with insert=INSERT, then > > - write the value you want into the returned slot. When inserting an > > - entry, NULL may be returned if memory allocation fails. */ > > - value_type **find_slot_with_hash (const compare_type *comparable, > > - hashval_t hash, enum insert_option insert); > > - > > - /* This function deletes an element with the given COMPARABLE value > > - from hash table starting with the given HASH. If there is no > > - matching element in the hash table, this function does nothing. */ > > - void remove_elt_with_hash (const compare_type *, hashval_t); > > - > > -/* Like remove_elt_with_hash, but compute the hash value from the element. */ > > - void remove_elt (const value_type *value) > > - { > > - remove_elt_with_hash (value, Descriptor::hash (value)); > > - } > > - > > - /* This function scans over the entire hash table calling CALLBACK for > > - each live entry. If CALLBACK returns false, the iteration stops. > > - ARGUMENT is passed as CALLBACK's second argument. */ > > - template <typename Argument, > > - int (*Callback) (value_type **slot, Argument argument)> > > - void traverse_noresize (Argument argument); > > - > > - /* Like traverse_noresize, but does resize the table when it is too empty > > - to improve effectivity of subsequent calls. */ > > - template <typename Argument, > > - int (*Callback) (value_type **slot, Argument argument)> > > - void traverse (Argument argument); > > - > > - class iterator > > - { > > - public: > > - iterator () : m_slot (NULL), m_limit (NULL) {} > > - > > - iterator (value_type **slot, value_type **limit) : > > - m_slot (slot), m_limit (limit) {} > > - > > - inline value_type *operator * () { return *m_slot; } > > - void slide (); > > - inline iterator &operator ++ (); > > - bool operator != (const iterator &other) const > > - { > > - return m_slot != other.m_slot || m_limit != other.m_limit; > > - } > > - > > - private: > > - value_type **m_slot; > > - value_type **m_limit; > > - }; > > - > > - iterator begin () const > > - { > > - iterator iter (m_entries, m_entries + m_size); > > - iter.slide (); > > - return iter; > > - } > > - > > - iterator end () const { return iterator (); } > > - > > - double collisions () const > > - { > > - return m_searches ? static_cast <double> (m_collisions) / m_searches : 0; > > - } > > - > > -private: > > - > > - value_type **find_empty_slot_for_expand (hashval_t); > > - void expand (); > > - > > - /* Table itself. */ > > - typename Descriptor::value_type **m_entries; > > - > > - size_t m_size; > > - > > - /* Current number of elements including also deleted elements. */ > > - size_t m_n_elements; > > - > > - /* Current number of deleted elements in the table. */ > > - size_t m_n_deleted; > > - > > - /* The following member is used for debugging. Its value is number > > - of all calls of `htab_find_slot' for the hash table. */ > > - unsigned int m_searches; > > - > > - /* The following member is used for debugging. Its value is number > > - of collisions fixed for time of work with the hash table. */ > > - unsigned int m_collisions; > > - > > - /* Current size (in entries) of the hash table, as an index into the > > - table of primes. */ > > - unsigned int m_size_prime_index; > > -}; > > - > > -template<typename Descriptor, template<typename Type> class Allocator> > > -hash_table<Descriptor, Allocator, false>::hash_table (size_t size > > - MEM_STAT_DECL) : > > - m_n_elements (0), m_n_deleted (0), m_searches (0), m_collisions (0) > > -{ > > - 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); > > - gcc_assert (m_entries != NULL); > > - m_size = size; > > - m_size_prime_index = size_prime_index; > > -} > > - > > -template<typename Descriptor, template<typename Type> class Allocator> > > -hash_table<Descriptor, Allocator, false>::~hash_table () > > -{ > > - for (size_t i = m_size - 1; i < m_size; i--) > > - if (m_entries[i] != HTAB_EMPTY_ENTRY && m_entries[i] != HTAB_DELETED_ENTRY) > > - Descriptor::remove (m_entries[i]); > > - > > - Allocator <value_type *> ::data_free (m_entries); > > -} > > - > > -/* Similar to find_slot, but without several unwanted side effects: > > - - Does not call equal when it finds an existing entry. > > - - Does not change the count of elements/searches/collisions in the > > - hash table. > > - This function also assumes there are no deleted entries in the table. > > - HASH is the hash value for the element to be inserted. */ > > - > > -template<typename Descriptor, template<typename Type> class Allocator> > > -typename hash_table<Descriptor, Allocator, false>::value_type ** > > -hash_table<Descriptor, Allocator, false> > > -::find_empty_slot_for_expand (hashval_t hash) > > -{ > > - hashval_t index = hash_table_mod1 (hash, m_size_prime_index); > > - size_t size = m_size; > > - value_type **slot = m_entries + index; > > - hashval_t hash2; > > - > > - if (*slot == HTAB_EMPTY_ENTRY) > > - return slot; > > - gcc_checking_assert (*slot != HTAB_DELETED_ENTRY); > > - > > - hash2 = hash_table_mod2 (hash, m_size_prime_index); > > - for (;;) > > - { > > - index += hash2; > > - if (index >= size) > > - index -= size; > > - > > - slot = m_entries + index; > > - if (*slot == HTAB_EMPTY_ENTRY) > > - return slot; > > - gcc_checking_assert (*slot != HTAB_DELETED_ENTRY); > > - } > > -} > > - > > -/* The following function changes size of memory allocated for the > > - entries and repeatedly inserts the table elements. The occupancy > > - of the table after the call will be about 50%. Naturally the hash > > - table must already exist. Remember also that the place of the > > - table entries is changed. If memory allocation fails, this function > > - will abort. */ > > - > > -template<typename Descriptor, template<typename Type> class Allocator> > > -void > > -hash_table<Descriptor, Allocator, false>::expand () > > -{ > > - value_type **oentries = m_entries; > > - unsigned int oindex = m_size_prime_index; > > - size_t osize = size (); > > - value_type **olimit = oentries + osize; > > - size_t elts = elements (); > > - > > - /* Resize only when table after removal of unused elements is either > > - too full or too empty. */ > > - unsigned int nindex; > > - size_t nsize; > > - if (elts * 2 > osize || (elts * 8 < osize && osize > 32)) > > - { > > - nindex = hash_table_higher_prime_index (elts * 2); > > - nsize = prime_tab[nindex].prime; > > - } > > - else > > - { > > - nindex = oindex; > > - nsize = osize; > > - } > > - > > - value_type **nentries = Allocator <value_type *> ::data_alloc (nsize); > > - gcc_assert (nentries != NULL); > > - m_entries = nentries; > > - m_size = nsize; > > - m_size_prime_index = nindex; > > - m_n_elements -= m_n_deleted; > > - m_n_deleted = 0; > > - > > - value_type **p = oentries; > > - do > > - { > > - value_type *x = *p; > > - > > - if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY) > > - { > > - value_type **q = find_empty_slot_for_expand (Descriptor::hash (x)); > > - > > - *q = x; > > - } > > - > > - p++; > > - } > > - while (p < olimit); > > - > > - Allocator <value_type *> ::data_free (oentries); > > -} > > - > > -template<typename Descriptor, template<typename Type> class Allocator> > > -void > > -hash_table<Descriptor, Allocator, false>::empty () > > -{ > > - size_t size = m_size; > > - value_type **entries = m_entries; > > - int i; > > - > > - for (i = size - 1; i >= 0; i--) > > - if (entries[i] != HTAB_EMPTY_ENTRY && entries[i] != HTAB_DELETED_ENTRY) > > - Descriptor::remove (entries[i]); > > - > > - /* Instead of clearing megabyte, downsize the table. */ > > - if (size > 1024*1024 / sizeof (PTR)) > > - { > > - 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); > > - m_size = nsize; > > - m_size_prime_index = nindex; > > - } > > - else > > - memset (entries, 0, size * sizeof (value_type *)); > > - m_n_deleted = 0; > > - m_n_elements = 0; > > -} > > - > > -/* This function clears a specified SLOT in a hash table. It is > > - useful when you've already done the lookup and don't want to do it > > - again. */ > > - > > -template<typename Descriptor, template<typename Type> class Allocator> > > -void > > -hash_table<Descriptor, Allocator, false>::clear_slot (value_type **slot) > > -{ > > - gcc_checking_assert (!(slot < m_entries || slot >= m_entries + size () > > - || *slot == HTAB_EMPTY_ENTRY > > - || *slot == HTAB_DELETED_ENTRY)); > > - > > - Descriptor::remove (*slot); > > - > > - *slot = static_cast <value_type *> (HTAB_DELETED_ENTRY); > > - m_n_deleted++; > > -} > > - > > -/* This function searches for a hash table entry equal to the given > > - COMPARABLE element starting with the given HASH value. It cannot > > - be used to insert or delete an element. */ > > - > > -template<typename Descriptor, template<typename Type> class Allocator> > > -typename hash_table<Descriptor, Allocator, false>::value_type * > > -hash_table<Descriptor, Allocator, false> > > -::find_with_hash (const compare_type *comparable, hashval_t hash) > > -{ > > - m_searches++; > > - size_t size = m_size; > > - hashval_t index = hash_table_mod1 (hash, m_size_prime_index); > > - > > - value_type *entry = m_entries[index]; > > - if (entry == HTAB_EMPTY_ENTRY > > - || (entry != HTAB_DELETED_ENTRY && Descriptor::equal (entry, comparable))) > > - return entry; > > - > > - hashval_t hash2 = hash_table_mod2 (hash, m_size_prime_index); > > - for (;;) > > - { > > - m_collisions++; > > - index += hash2; > > - if (index >= size) > > - index -= size; > > - > > - entry = m_entries[index]; > > - if (entry == HTAB_EMPTY_ENTRY > > - || (entry != HTAB_DELETED_ENTRY > > - && Descriptor::equal (entry, comparable))) > > - return entry; > > - } > > -} > > - > > -/* This function searches for a hash table slot containing an entry > > - equal to the given COMPARABLE element and starting with the given > > - HASH. To delete an entry, call this with insert=NO_INSERT, then > > - call clear_slot on the slot returned (possibly after doing some > > - checks). To insert an entry, call this with insert=INSERT, then > > - write the value you want into the returned slot. When inserting an > > - entry, NULL may be returned if memory allocation fails. */ > > - > > -template<typename Descriptor, template<typename Type> class Allocator> > > -typename hash_table<Descriptor, Allocator, false>::value_type ** > > -hash_table<Descriptor, Allocator, false> > > -::find_slot_with_hash (const compare_type *comparable, hashval_t hash, > > - enum insert_option insert) > > -{ > > - if (insert == INSERT && m_size * 3 <= m_n_elements * 4) > > - expand (); > > - > > - m_searches++; > > - > > - value_type **first_deleted_slot = NULL; > > - hashval_t index = hash_table_mod1 (hash, m_size_prime_index); > > - hashval_t hash2 = hash_table_mod2 (hash, m_size_prime_index); > > - value_type *entry = m_entries[index]; > > - size_t size = m_size; > > - if (entry == HTAB_EMPTY_ENTRY) > > - goto empty_entry; > > - else if (entry == HTAB_DELETED_ENTRY) > > - first_deleted_slot = &m_entries[index]; > > - else if (Descriptor::equal (entry, comparable)) > > - return &m_entries[index]; > > - > > - for (;;) > > - { > > - m_collisions++; > > - index += hash2; > > - if (index >= size) > > - index -= size; > > - > > - entry = m_entries[index]; > > - if (entry == HTAB_EMPTY_ENTRY) > > - goto empty_entry; > > - else if (entry == HTAB_DELETED_ENTRY) > > - { > > - if (!first_deleted_slot) > > - first_deleted_slot = &m_entries[index]; > > - } > > - else if (Descriptor::equal (entry, comparable)) > > - return &m_entries[index]; > > - } > > - > > - empty_entry: > > - if (insert == NO_INSERT) > > - return NULL; > > - > > - if (first_deleted_slot) > > - { > > - m_n_deleted--; > > - *first_deleted_slot = static_cast <value_type *> (HTAB_EMPTY_ENTRY); > > - return first_deleted_slot; > > - } > > - > > - m_n_elements++; > > - return &m_entries[index]; > > -} > > - > > -/* This function deletes an element with the given COMPARABLE value > > - from hash table starting with the given HASH. If there is no > > - matching element in the hash table, this function does nothing. */ > > - > > -template<typename Descriptor, template<typename Type> class Allocator> > > -void > > -hash_table<Descriptor, Allocator, false> > > -::remove_elt_with_hash (const compare_type *comparable, hashval_t hash) > > -{ > > - value_type **slot = find_slot_with_hash (comparable, hash, NO_INSERT); > > - if (*slot == HTAB_EMPTY_ENTRY) > > - return; > > - > > - Descriptor::remove (*slot); > > - > > - *slot = static_cast <value_type *> (HTAB_DELETED_ENTRY); > > - m_n_deleted++; > > -} > > - > > -/* This function scans over the entire hash table calling CALLBACK for > > - each live entry. If CALLBACK returns false, the iteration stops. > > - ARGUMENT is passed as CALLBACK's second argument. */ > > - > > -template<typename Descriptor, template<typename Type> class Allocator> > > -template<typename Argument, > > - int (*Callback) (typename hash_table<Descriptor, Allocator, > > - false>::value_type **slot, > > - Argument argument)> > > -void > > -hash_table<Descriptor, Allocator, false>::traverse_noresize (Argument argument) > > -{ > > - value_type **slot = m_entries; > > - value_type **limit = slot + size (); > > - > > - do > > - { > > - value_type *x = *slot; > > - > > - if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY) > > - if (! Callback (slot, argument)) > > - break; > > - } > > - while (++slot < limit); > > -} > > - > > -/* Like traverse_noresize, but does resize the table when it is too empty > > - to improve effectivity of subsequent calls. */ > > - > > -template <typename Descriptor, > > - template <typename Type> class Allocator> > > -template <typename Argument, > > - int (*Callback) (typename hash_table<Descriptor, Allocator, > > - false>::value_type **slot, > > - Argument argument)> > > -void > > -hash_table<Descriptor, Allocator, false>::traverse (Argument argument) > > -{ > > - size_t size = m_size; > > - if (elements () * 8 < size && size > 32) > > - expand (); > > - > > - traverse_noresize <Argument, Callback> (argument); > > -} > > - > > -/* Slide down the iterator slots until an active entry is found. */ > > - > > -template<typename Descriptor, template<typename Type> class Allocator> > > -void > > -hash_table<Descriptor, Allocator, false>::iterator::slide () > > -{ > > - for ( ; m_slot < m_limit; ++m_slot ) > > - { > > - value_type *x = *m_slot; > > - if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY) > > - return; > > - } > > - m_slot = NULL; > > - m_limit = NULL; > > -} > > - > > -/* Bump the iterator. */ > > - > > -template<typename Descriptor, template<typename Type> class Allocator> > > -inline typename hash_table<Descriptor, Allocator, false>::iterator & > > -hash_table<Descriptor, Allocator, false>::iterator::operator ++ () > > -{ > > - ++m_slot; > > - slide (); > > - return *this; > > -} > > - > > -/* A partial specialization used when values should be stored directly. */ > > - > > -template <typename Descriptor, > > - template<typename Type> class Allocator> > > -class hash_table<Descriptor, Allocator, true> > > -{ > > typedef typename Descriptor::value_type value_type; > > typedef typename Descriptor::compare_type compare_type; > > > > @@ -1296,7 +762,7 @@ private: > > }; > > > > template<typename Descriptor, template<typename Type> class Allocator> > > -hash_table<Descriptor, Allocator, true>::hash_table (size_t size, bool ggc > > +hash_table<Descriptor, Allocator>::hash_table (size_t size, bool ggc > > MEM_STAT_DECL) : > > m_n_elements (0), m_n_deleted (0), m_searches (0), m_collisions (0), > > m_ggc (ggc) > > @@ -1312,7 +778,7 @@ hash_table<Descriptor, Allocator, true>::hash_table (size_t size, bool ggc > > } > > > > template<typename Descriptor, template<typename Type> class Allocator> > > -hash_table<Descriptor, Allocator, true>::~hash_table () > > +hash_table<Descriptor, Allocator>::~hash_table () > > { > > for (size_t i = m_size - 1; i < m_size; i--) > > if (!is_empty (m_entries[i]) && !is_deleted (m_entries[i])) > > @@ -1327,9 +793,8 @@ hash_table<Descriptor, Allocator, true>::~hash_table () > > /* This function returns an array of empty hash table elements. */ > > > > template<typename Descriptor, template<typename Type> class Allocator> > > -inline typename hash_table<Descriptor, Allocator, true>::value_type * > > -hash_table<Descriptor, Allocator, true>::alloc_entries > > - (size_t n MEM_STAT_DECL) const > > +inline typename hash_table<Descriptor, Allocator>::value_type * > > +hash_table<Descriptor, Allocator>::alloc_entries (size_t n MEM_STAT_DECL) const > > { > > value_type *nentries; > > > > @@ -1353,9 +818,8 @@ hash_table<Descriptor, Allocator, true>::alloc_entries > > HASH is the hash value for the element to be inserted. */ > > > > template<typename Descriptor, template<typename Type> class Allocator> > > -typename hash_table<Descriptor, Allocator, true>::value_type * > > -hash_table<Descriptor, Allocator, true> > > -::find_empty_slot_for_expand (hashval_t hash) > > +typename hash_table<Descriptor, Allocator>::value_type * > > +hash_table<Descriptor, Allocator>::find_empty_slot_for_expand (hashval_t hash) > > { > > hashval_t index = hash_table_mod1 (hash, m_size_prime_index); > > size_t size = m_size; > > @@ -1393,7 +857,7 @@ hash_table<Descriptor, Allocator, true> > > > > template<typename Descriptor, template<typename Type> class Allocator> > > void > > -hash_table<Descriptor, Allocator, true>::expand () > > +hash_table<Descriptor, Allocator>::expand () > > { > > value_type *oentries = m_entries; > > unsigned int oindex = m_size_prime_index; > > @@ -1447,7 +911,7 @@ hash_table<Descriptor, Allocator, true>::expand () > > > > template<typename Descriptor, template<typename Type> class Allocator> > > void > > -hash_table<Descriptor, Allocator, true>::empty () > > +hash_table<Descriptor, Allocator>::empty () > > { > > size_t size = m_size; > > value_type *entries = m_entries; > > @@ -1484,7 +948,7 @@ hash_table<Descriptor, Allocator, true>::empty () > > > > template<typename Descriptor, template<typename Type> class Allocator> > > void > > -hash_table<Descriptor, Allocator, true>::clear_slot (value_type *slot) > > +hash_table<Descriptor, Allocator>::clear_slot (value_type *slot) > > { > > gcc_checking_assert (!(slot < m_entries || slot >= m_entries + size () > > || is_empty (*slot) || is_deleted (*slot))); > > @@ -1500,8 +964,8 @@ hash_table<Descriptor, Allocator, true>::clear_slot (value_type *slot) > > be used to insert or delete an element. */ > > > > template<typename Descriptor, template<typename Type> class Allocator> > > -typename hash_table<Descriptor, Allocator, true>::value_type & > > -hash_table<Descriptor, Allocator, true> > > +typename hash_table<Descriptor, Allocator>::value_type & > > +hash_table<Descriptor, Allocator> > > ::find_with_hash (const compare_type &comparable, hashval_t hash) > > { > > m_searches++; > > @@ -1537,8 +1001,8 @@ hash_table<Descriptor, Allocator, true> > > entry, NULL may be returned if memory allocation fails. */ > > > > template<typename Descriptor, template<typename Type> class Allocator> > > -typename hash_table<Descriptor, Allocator, true>::value_type * > > -hash_table<Descriptor, Allocator, true> > > +typename hash_table<Descriptor, Allocator>::value_type * > > +hash_table<Descriptor, Allocator> > > ::find_slot_with_hash (const compare_type &comparable, hashval_t hash, > > enum insert_option insert) > > { > > @@ -1599,7 +1063,7 @@ hash_table<Descriptor, Allocator, true> > > > > template<typename Descriptor, template<typename Type> class Allocator> > > void > > -hash_table<Descriptor, Allocator, true> > > +hash_table<Descriptor, Allocator> > > ::remove_elt_with_hash (const compare_type &comparable, hashval_t hash) > > { > > value_type *slot = find_slot_with_hash (comparable, hash, NO_INSERT); > > @@ -1619,11 +1083,11 @@ hash_table<Descriptor, Allocator, true> > > template<typename Descriptor, > > template<typename Type> class Allocator> > > template<typename Argument, > > - int (*Callback) (typename hash_table<Descriptor, Allocator, > > - true>::value_type *slot, > > - Argument argument)> > > + int (*Callback) > > + (typename hash_table<Descriptor, Allocator>::value_type *slot, > > + Argument argument)> > > void > > -hash_table<Descriptor, Allocator, true>::traverse_noresize (Argument argument) > > +hash_table<Descriptor, Allocator>::traverse_noresize (Argument argument) > > { > > value_type *slot = m_entries; > > value_type *limit = slot + size (); > > @@ -1645,11 +1109,11 @@ hash_table<Descriptor, Allocator, true>::traverse_noresize (Argument argument) > > template <typename Descriptor, > > template <typename Type> class Allocator> > > template <typename Argument, > > - int (*Callback) (typename hash_table<Descriptor, Allocator, > > - true>::value_type *slot, > > - Argument argument)> > > + int (*Callback) > > + (typename hash_table<Descriptor, Allocator>::value_type *slot, > > + Argument argument)> > > void > > -hash_table<Descriptor, Allocator, true>::traverse (Argument argument) > > +hash_table<Descriptor, Allocator>::traverse (Argument argument) > > { > > size_t size = m_size; > > if (elements () * 8 < size && size > 32) > > @@ -1662,7 +1126,7 @@ hash_table<Descriptor, Allocator, true>::traverse (Argument argument) > > > > template<typename Descriptor, template<typename Type> class Allocator> > > void > > -hash_table<Descriptor, Allocator, true>::iterator::slide () > > +hash_table<Descriptor, Allocator>::iterator::slide () > > { > > for ( ; m_slot < m_limit; ++m_slot ) > > { > > @@ -1677,8 +1141,8 @@ hash_table<Descriptor, Allocator, true>::iterator::slide () > > /* Bump the iterator. */ > > > > template<typename Descriptor, template<typename Type> class Allocator> > > -inline typename hash_table<Descriptor, Allocator, true>::iterator & > > -hash_table<Descriptor, Allocator, true>::iterator::operator ++ () > > +inline typename hash_table<Descriptor, Allocator>::iterator & > > +hash_table<Descriptor, Allocator>::iterator::operator ++ () > > { > > ++m_slot; > > slide (); > > diff --git a/gcc/ipa-devirt.c b/gcc/ipa-devirt.c > > index 6969f5a..7214a74 100644 > > --- a/gcc/ipa-devirt.c > > +++ b/gcc/ipa-devirt.c > > @@ -308,11 +308,11 @@ type_possibly_instantiated_p (tree t) > > > > struct odr_name_hasher > > { > > - typedef odr_type_d value_type; > > - typedef union tree_node compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > - static inline void remove (value_type *); > > + typedef odr_type_d *value_type; > > + typedef union tree_node *compare_type; > > + static inline hashval_t hash (const odr_type_d *); > > + static inline bool equal (const odr_type_d *, const tree_node *); > > + static inline void remove (odr_type_d *); > > }; > > > > /* Has used to unify ODR types based on their associated virtual table. > > @@ -321,8 +321,8 @@ struct odr_name_hasher > > > > struct odr_vtable_hasher:odr_name_hasher > > { > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + static inline hashval_t hash (const odr_type_d *); > > + static inline bool equal (const odr_type_d *, const tree_node *); > > }; > > > > /* Return type that was declared with T's name so that T is an > > @@ -369,7 +369,7 @@ hash_odr_name (const_tree t) > > /* Return the computed hashcode for ODR_TYPE. */ > > > > inline hashval_t > > -odr_name_hasher::hash (const value_type *odr_type) > > +odr_name_hasher::hash (const odr_type_d *odr_type) > > { > > return hash_odr_name (odr_type->type); > > } > > @@ -414,7 +414,7 @@ hash_odr_vtable (const_tree t) > > /* Return the computed hashcode for ODR_TYPE. */ > > > > inline hashval_t > > -odr_vtable_hasher::hash (const value_type *odr_type) > > +odr_vtable_hasher::hash (const odr_type_d *odr_type) > > { > > return hash_odr_vtable (odr_type->type); > > } > > @@ -553,7 +553,7 @@ types_must_be_same_for_odr (tree t1, tree t2) > > equivalent. */ > > > > inline bool > > -odr_name_hasher::equal (const value_type *o1, const compare_type *t2) > > +odr_name_hasher::equal (const odr_type_d *o1, const tree_node *t2) > > { > > tree t1 = o1->type; > > > > @@ -578,7 +578,7 @@ odr_name_hasher::equal (const value_type *o1, const compare_type *t2) > > equivalent. */ > > > > inline bool > > -odr_vtable_hasher::equal (const value_type *o1, const compare_type *t2) > > +odr_vtable_hasher::equal (const odr_type_d *o1, const tree_node *t2) > > { > > tree t1 = o1->type; > > > > @@ -602,7 +602,7 @@ odr_vtable_hasher::equal (const value_type *o1, const compare_type *t2) > > /* Free ODR type V. */ > > > > inline void > > -odr_name_hasher::remove (value_type *v) > > +odr_name_hasher::remove (odr_type_d *v) > > { > > v->bases.release (); > > v->derived_types.release (); > > @@ -2507,17 +2507,18 @@ struct polymorphic_call_target_d > > > > struct polymorphic_call_target_hasher > > { > > - typedef polymorphic_call_target_d value_type; > > - typedef polymorphic_call_target_d compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > - static inline void remove (value_type *); > > + typedef polymorphic_call_target_d *value_type; > > + typedef polymorphic_call_target_d *compare_type; > > + static inline hashval_t hash (const polymorphic_call_target_d *); > > + static inline bool equal (const polymorphic_call_target_d *, > > + const polymorphic_call_target_d *); > > + static inline void remove (polymorphic_call_target_d *); > > }; > > > > /* Return the computed hashcode for ODR_QUERY. */ > > > > inline hashval_t > > -polymorphic_call_target_hasher::hash (const value_type *odr_query) > > +polymorphic_call_target_hasher::hash (const polymorphic_call_target_d *odr_query) > > { > > inchash::hash hstate (odr_query->otr_token); > > > > @@ -2541,8 +2542,8 @@ polymorphic_call_target_hasher::hash (const value_type *odr_query) > > /* Compare cache entries T1 and T2. */ > > > > inline bool > > -polymorphic_call_target_hasher::equal (const value_type *t1, > > - const compare_type *t2) > > +polymorphic_call_target_hasher::equal (const polymorphic_call_target_d *t1, > > + const polymorphic_call_target_d *t2) > > { > > return (t1->type == t2->type && t1->otr_token == t2->otr_token > > && t1->speculative == t2->speculative > > @@ -2560,7 +2561,7 @@ polymorphic_call_target_hasher::equal (const value_type *t1, > > /* Remove entry in polymorphic call target cache hash. */ > > > > inline void > > -polymorphic_call_target_hasher::remove (value_type *v) > > +polymorphic_call_target_hasher::remove (polymorphic_call_target_d *v) > > { > > v->targets.release (); > > free (v); > > diff --git a/gcc/ipa-icf.h b/gcc/ipa-icf.h > > index 7eb9f27..b9d70b4 100644 > > --- a/gcc/ipa-icf.h > > +++ b/gcc/ipa-icf.h > > @@ -429,15 +429,16 @@ struct congruence_class_group > > /* Congruence class set structure. */ > > struct congruence_class_group_hash: typed_noop_remove <congruence_class_group> > > { > > - typedef congruence_class_group value_type; > > - typedef congruence_class_group compare_type; > > + typedef congruence_class_group *value_type; > > + typedef congruence_class_group *compare_type; > > > > - static inline hashval_t hash (const value_type *item) > > + static inline hashval_t hash (const congruence_class_group *item) > > { > > return item->hash; > > } > > > > - static inline int equal (const value_type *item1, const compare_type *item2) > > + static inline int equal (const congruence_class_group *item1, > > + const congruence_class_group *item2) > > { > > return item1->hash == item2->hash && item1->type == item2->type; > > } > > diff --git a/gcc/ipa-profile.c b/gcc/ipa-profile.c > > index e9f937f..96fb810 100644 > > --- a/gcc/ipa-profile.c > > +++ b/gcc/ipa-profile.c > > @@ -113,10 +113,10 @@ static alloc_pool histogram_pool; > > > > struct histogram_hash : typed_noop_remove <histogram_entry> > > { > > - typedef histogram_entry value_type; > > - typedef histogram_entry compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline int equal (const value_type *, const compare_type *); > > + typedef histogram_entry *value_type; > > + typedef histogram_entry *compare_type; > > + static inline hashval_t hash (const histogram_entry *); > > + static inline int equal (const histogram_entry *, const histogram_entry *); > > }; > > > > inline hashval_t > > diff --git a/gcc/ira-color.c b/gcc/ira-color.c > > index ff1fe8a..bc0692d 100644 > > --- a/gcc/ira-color.c > > +++ b/gcc/ira-color.c > > @@ -227,22 +227,24 @@ static vec<allocno_hard_regs_t> allocno_hard_regs_vec; > > > > struct allocno_hard_regs_hasher : typed_noop_remove <allocno_hard_regs> > > { > > - typedef allocno_hard_regs value_type; > > - typedef allocno_hard_regs compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef allocno_hard_regs *value_type; > > + typedef allocno_hard_regs *compare_type; > > + static inline hashval_t hash (const allocno_hard_regs *); > > + static inline bool equal (const allocno_hard_regs *, > > + const allocno_hard_regs *); > > }; > > > > /* Returns hash value for allocno hard registers V. */ > > inline hashval_t > > -allocno_hard_regs_hasher::hash (const value_type *hv) > > +allocno_hard_regs_hasher::hash (const allocno_hard_regs *hv) > > { > > return iterative_hash (&hv->set, sizeof (HARD_REG_SET), 0); > > } > > > > /* Compares allocno hard registers V1 and V2. */ > > inline bool > > -allocno_hard_regs_hasher::equal (const value_type *hv1, const compare_type *hv2) > > +allocno_hard_regs_hasher::equal (const allocno_hard_regs *hv1, > > + const allocno_hard_regs *hv2) > > { > > return hard_reg_set_equal_p (hv1->set, hv2->set); > > } > > diff --git a/gcc/ira-costs.c b/gcc/ira-costs.c > > index 354ba6b..5358440 100644 > > --- a/gcc/ira-costs.c > > +++ b/gcc/ira-costs.c > > @@ -161,23 +161,23 @@ static cost_classes_t *regno_cost_classes; > > > > struct cost_classes_hasher > > { > > - typedef cost_classes value_type; > > - typedef cost_classes compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > - static inline void remove (value_type *); > > + typedef cost_classes *value_type; > > + typedef cost_classes *compare_type; > > + static inline hashval_t hash (const cost_classes *); > > + static inline bool equal (const cost_classes *, const cost_classes *); > > + static inline void remove (cost_classes *); > > }; > > > > /* Returns hash value for cost classes info HV. */ > > inline hashval_t > > -cost_classes_hasher::hash (const value_type *hv) > > +cost_classes_hasher::hash (const cost_classes *hv) > > { > > return iterative_hash (&hv->classes, sizeof (enum reg_class) * hv->num, 0); > > } > > > > /* Compares cost classes info HV1 and HV2. */ > > inline bool > > -cost_classes_hasher::equal (const value_type *hv1, const compare_type *hv2) > > +cost_classes_hasher::equal (const cost_classes *hv1, const cost_classes *hv2) > > { > > return (hv1->num == hv2->num > > && memcmp (hv1->classes, hv2->classes, > > @@ -186,7 +186,7 @@ cost_classes_hasher::equal (const value_type *hv1, const compare_type *hv2) > > > > /* Delete cost classes info V from the hash table. */ > > inline void > > -cost_classes_hasher::remove (value_type *v) > > +cost_classes_hasher::remove (cost_classes *v) > > { > > ira_free (v); > > } > > diff --git a/gcc/java/jcf-io.c b/gcc/java/jcf-io.c > > index 2c48f14..36ceb07 100644 > > --- a/gcc/java/jcf-io.c > > +++ b/gcc/java/jcf-io.c > > @@ -285,21 +285,20 @@ find_classfile (char *filename, JCF *jcf, const char *dep_name) > > > > struct charstar_hash : typed_noop_remove <char> > > { > > - typedef const char value_type; > > - typedef const char compare_type; > > - static inline hashval_t hash (const value_type *candidate); > > - static inline bool equal (const value_type *existing, > > - const compare_type *candidate); > > + typedef const char *value_type; > > + typedef const char *compare_type; > > + static inline hashval_t hash (const char *candidate); > > + static inline bool equal (const char *existing, const char *candidate); > > }; > > > > inline hashval_t > > -charstar_hash::hash (const value_type *candidate) > > +charstar_hash::hash (const char *candidate) > > { > > return htab_hash_string (candidate); > > } > > > > inline bool > > -charstar_hash::equal (const value_type *existing, const compare_type *candidate) > > +charstar_hash::equal (const char *existing, const char *candidate) > > { > > return strcmp (existing, candidate) == 0; > > } > > diff --git a/gcc/loop-invariant.c b/gcc/loop-invariant.c > > index f79b497..52ecc05 100644 > > --- a/gcc/loop-invariant.c > > +++ b/gcc/loop-invariant.c > > @@ -455,16 +455,17 @@ invariant_expr_equal_p (rtx_insn *insn1, rtx e1, rtx_insn *insn2, rtx e2) > > > > struct invariant_expr_hasher : typed_free_remove <invariant_expr_entry> > > { > > - typedef invariant_expr_entry value_type; > > - typedef invariant_expr_entry compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef invariant_expr_entry *value_type; > > + typedef invariant_expr_entry *compare_type; > > + static inline hashval_t hash (const invariant_expr_entry *); > > + static inline bool equal (const invariant_expr_entry *, > > + const invariant_expr_entry *); > > }; > > > > /* Returns hash value for invariant expression entry ENTRY. */ > > > > inline hashval_t > > -invariant_expr_hasher::hash (const value_type *entry) > > +invariant_expr_hasher::hash (const invariant_expr_entry *entry) > > { > > return entry->hash; > > } > > @@ -472,8 +473,8 @@ invariant_expr_hasher::hash (const value_type *entry) > > /* Compares invariant expression entries ENTRY1 and ENTRY2. */ > > > > inline bool > > -invariant_expr_hasher::equal (const value_type *entry1, > > - const compare_type *entry2) > > +invariant_expr_hasher::equal (const invariant_expr_entry *entry1, > > + const invariant_expr_entry *entry2) > > { > > if (entry1->mode != entry2->mode) > > return 0; > > diff --git a/gcc/loop-iv.c b/gcc/loop-iv.c > > index de2b15a..36a9a9f 100644 > > --- a/gcc/loop-iv.c > > +++ b/gcc/loop-iv.c > > @@ -138,16 +138,16 @@ static struct loop *current_loop; > > > > struct biv_entry_hasher : typed_free_remove <biv_entry> > > { > > - typedef biv_entry value_type; > > - typedef rtx_def compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef biv_entry *value_type; > > + typedef rtx_def *compare_type; > > + static inline hashval_t hash (const biv_entry *); > > + static inline bool equal (const biv_entry *, const rtx_def *); > > }; > > > > /* Returns hash value for biv B. */ > > > > inline hashval_t > > -biv_entry_hasher::hash (const value_type *b) > > +biv_entry_hasher::hash (const biv_entry *b) > > { > > return b->regno; > > } > > @@ -155,7 +155,7 @@ biv_entry_hasher::hash (const value_type *b) > > /* Compares biv B and register R. */ > > > > inline bool > > -biv_entry_hasher::equal (const value_type *b, const compare_type *r) > > +biv_entry_hasher::equal (const biv_entry *b, const rtx_def *r) > > { > > return b->regno == REGNO (r); > > } > > diff --git a/gcc/loop-unroll.c b/gcc/loop-unroll.c > > index 2befb61..ccf473d 100644 > > --- a/gcc/loop-unroll.c > > +++ b/gcc/loop-unroll.c > > @@ -126,17 +126,17 @@ struct var_to_expand > > > > struct iv_split_hasher : typed_free_remove <iv_to_split> > > { > > - typedef iv_to_split value_type; > > - typedef iv_to_split compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef iv_to_split *value_type; > > + typedef iv_to_split *compare_type; > > + static inline hashval_t hash (const iv_to_split *); > > + static inline bool equal (const iv_to_split *, const iv_to_split *); > > }; > > > > > > /* A hash function for information about insns to split. */ > > > > inline hashval_t > > -iv_split_hasher::hash (const value_type *ivts) > > +iv_split_hasher::hash (const iv_to_split *ivts) > > { > > return (hashval_t) INSN_UID (ivts->insn); > > } > > @@ -144,7 +144,7 @@ iv_split_hasher::hash (const value_type *ivts) > > /* An equality functions for information about insns to split. */ > > > > inline bool > > -iv_split_hasher::equal (const value_type *i1, const compare_type *i2) > > +iv_split_hasher::equal (const iv_to_split *i1, const iv_to_split *i2) > > { > > return i1->insn == i2->insn; > > } > > @@ -153,16 +153,16 @@ iv_split_hasher::equal (const value_type *i1, const compare_type *i2) > > > > struct var_expand_hasher : typed_free_remove <var_to_expand> > > { > > - typedef var_to_expand value_type; > > - typedef var_to_expand compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef var_to_expand *value_type; > > + typedef var_to_expand *compare_type; > > + static inline hashval_t hash (const var_to_expand *); > > + static inline bool equal (const var_to_expand *, const var_to_expand *); > > }; > > > > /* Return a hash for VES. */ > > > > inline hashval_t > > -var_expand_hasher::hash (const value_type *ves) > > +var_expand_hasher::hash (const var_to_expand *ves) > > { > > return (hashval_t) INSN_UID (ves->insn); > > } > > @@ -170,7 +170,7 @@ var_expand_hasher::hash (const value_type *ves) > > /* Return true if I1 and I2 refer to the same instruction. */ > > > > inline bool > > -var_expand_hasher::equal (const value_type *i1, const compare_type *i2) > > +var_expand_hasher::equal (const var_to_expand *i1, const var_to_expand *i2) > > { > > return i1->insn == i2->insn; > > } > > diff --git a/gcc/lto-streamer.h b/gcc/lto-streamer.h > > index b383631..e3465a8 100644 > > --- a/gcc/lto-streamer.h > > +++ b/gcc/lto-streamer.h > > @@ -657,17 +657,17 @@ struct string_slot > > > > struct string_slot_hasher : typed_noop_remove <string_slot> > > { > > - typedef string_slot value_type; > > - typedef string_slot compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef string_slot *value_type; > > + typedef string_slot *compare_type; > > + static inline hashval_t hash (const string_slot *); > > + static inline bool equal (const string_slot *, const string_slot *); > > }; > > > > /* Returns a hash code for DS. Adapted from libiberty's htab_hash_string > > to support strings that may not end in '\0'. */ > > > > inline hashval_t > > -string_slot_hasher::hash (const value_type *ds) > > +string_slot_hasher::hash (const string_slot *ds) > > { > > hashval_t r = ds->len; > > int i; > > @@ -680,7 +680,7 @@ string_slot_hasher::hash (const value_type *ds) > > /* Returns nonzero if DS1 and DS2 are equal. */ > > > > inline bool > > -string_slot_hasher::equal (const value_type *ds1, const compare_type *ds2) > > +string_slot_hasher::equal (const string_slot *ds1, const string_slot *ds2) > > { > > if (ds1->len == ds2->len) > > return memcmp (ds1->s, ds2->s, ds1->len) == 0; > > diff --git a/gcc/lto/lto.c b/gcc/lto/lto.c > > index 360aeed..f3458c7 100644 > > --- a/gcc/lto/lto.c > > +++ b/gcc/lto/lto.c > > @@ -1143,20 +1143,20 @@ struct tree_scc > > > > struct tree_scc_hasher : typed_noop_remove <tree_scc> > > { > > - typedef tree_scc value_type; > > - typedef tree_scc compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef tree_scc *value_type; > > + typedef tree_scc *compare_type; > > + static inline hashval_t hash (const tree_scc *); > > + static inline bool equal (const tree_scc *, const tree_scc *); > > }; > > > > hashval_t > > -tree_scc_hasher::hash (const value_type *scc) > > +tree_scc_hasher::hash (const tree_scc *scc) > > { > > return scc->hash; > > } > > > > bool > > -tree_scc_hasher::equal (const value_type *scc1, const compare_type *scc2) > > +tree_scc_hasher::equal (const tree_scc *scc1, const tree_scc *scc2) > > { > > if (scc1->hash != scc2->hash > > || scc1->len != scc2->len > > diff --git a/gcc/objc/objc-act.c b/gcc/objc/objc-act.c > > index 6bd4dcc..718fdf0 100644 > > --- a/gcc/objc/objc-act.c > > +++ b/gcc/objc/objc-act.c > > @@ -3871,20 +3871,20 @@ objc_get_class_ivars (tree class_name) > > > > struct decl_name_hash : typed_noop_remove <tree_node> > > { > > - typedef tree_node value_type; > > - typedef tree_node compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef tree_node *value_type; > > + typedef tree_node *compare_type; > > + static inline hashval_t hash (const tree_node *); > > + static inline bool equal (const tree_node *, const tree_node *); > > }; > > > > inline hashval_t > > -decl_name_hash::hash (const value_type *q) > > +decl_name_hash::hash (const tree_node *q) > > { > > return (hashval_t) ((intptr_t)(DECL_NAME (q)) >> 3); > > } > > > > inline bool > > -decl_name_hash::equal (const value_type *a, const compare_type *b) > > +decl_name_hash::equal (const tree_node *a, const tree_node *b) > > { > > return DECL_NAME (a) == DECL_NAME (b); > > } > > diff --git a/gcc/plugin.c b/gcc/plugin.c > > index d924438..6a7654f 100644 > > --- a/gcc/plugin.c > > +++ b/gcc/plugin.c > > @@ -66,16 +66,16 @@ const char **plugin_event_name = plugin_event_name_init; > > > > struct event_hasher : typed_noop_remove <const char *> > > { > > - typedef const char *value_type; > > - typedef const char *compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef const char **value_type; > > + typedef const char **compare_type; > > + static inline hashval_t hash (const char **); > > + static inline bool equal (const char **, const char **); > > }; > > > > /* Helper function for the event hash table that hashes the entry V. */ > > > > inline hashval_t > > -event_hasher::hash (const value_type *v) > > +event_hasher::hash (const char **v) > > { > > return htab_hash_string (*v); > > } > > @@ -84,7 +84,7 @@ event_hasher::hash (const value_type *v) > > existing entry (S1) with the given string (S2). */ > > > > inline bool > > -event_hasher::equal (const value_type *s1, const compare_type *s2) > > +event_hasher::equal (const char **s1, const char **s2) > > { > > return !strcmp (*s1, *s2); > > } > > diff --git a/gcc/postreload-gcse.c b/gcc/postreload-gcse.c > > index 83048bd..9014d69 100644 > > --- a/gcc/postreload-gcse.c > > +++ b/gcc/postreload-gcse.c > > @@ -134,10 +134,10 @@ struct expr > > > > struct expr_hasher : typed_noop_remove <expr> > > { > > - typedef expr value_type; > > - typedef expr compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef expr *value_type; > > + typedef expr *compare_type; > > + static inline hashval_t hash (const expr *); > > + static inline bool equal (const expr *, const expr *); > > }; > > > > > > @@ -159,7 +159,7 @@ hash_expr (rtx x, int *do_not_record_p) > > here, we just return the cached hash value. */ > > > > inline hashval_t > > -expr_hasher::hash (const value_type *exp) > > +expr_hasher::hash (const expr *exp) > > { > > return exp->hash; > > } > > @@ -168,7 +168,7 @@ expr_hasher::hash (const value_type *exp) > > Return nonzero if exp1 is equivalent to exp2. */ > > > > inline bool > > -expr_hasher::equal (const value_type *exp1, const compare_type *exp2) > > +expr_hasher::equal (const expr *exp1, const expr *exp2) > > { > > int equiv_p = exp_equiv_p (exp1->expr, exp2->expr, 0, true); > > > > diff --git a/gcc/reginfo.c b/gcc/reginfo.c > > index 9015eeb..6678688 100644 > > --- a/gcc/reginfo.c > > +++ b/gcc/reginfo.c > > @@ -85,15 +85,6 @@ struct simplifiable_subreg > > subreg_shape shape; > > HARD_REG_SET simplifiable_regs; > > }; > > - > > -struct simplifiable_subregs_hasher : typed_noop_remove <simplifiable_subreg> > > -{ > > - typedef simplifiable_subreg value_type; > > - typedef subreg_shape compare_type; > > - > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > -}; > > > > struct target_hard_regs default_target_hard_regs; > > struct target_regs default_target_regs; > > @@ -1234,14 +1225,14 @@ reg_classes_intersect_p (reg_class_t c1, reg_class_t c2) > > > > > > inline hashval_t > > -simplifiable_subregs_hasher::hash (const value_type *value) > > +simplifiable_subregs_hasher::hash (const simplifiable_subreg *value) > > { > > return value->shape.unique_id (); > > } > > > > inline bool > > -simplifiable_subregs_hasher::equal (const value_type *value, > > - const compare_type *compare) > > +simplifiable_subregs_hasher::equal (const simplifiable_subreg *value, > > + const subreg_shape *compare) > > { > > return value->shape == *compare; > > } > > diff --git a/gcc/statistics.c b/gcc/statistics.c > > index b76de15..8cbe88d 100644 > > --- a/gcc/statistics.c > > +++ b/gcc/statistics.c > > @@ -55,17 +55,18 @@ typedef struct statistics_counter_s { > > > > struct stats_counter_hasher > > { > > - typedef statistics_counter_t value_type; > > - typedef statistics_counter_t compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > - static inline void remove (value_type *); > > + typedef statistics_counter_t *value_type; > > + typedef statistics_counter_t *compare_type; > > + static inline hashval_t hash (const statistics_counter_t *); > > + static inline bool equal (const statistics_counter_t *, > > + const statistics_counter_t *); > > + static inline void remove (statistics_counter_t *); > > }; > > > > /* Hash a statistic counter by its string ID. */ > > > > inline hashval_t > > -stats_counter_hasher::hash (const value_type *c) > > +stats_counter_hasher::hash (const statistics_counter_t *c) > > { > > return htab_hash_string (c->id) + c->val; > > } > > @@ -73,7 +74,8 @@ stats_counter_hasher::hash (const value_type *c) > > /* Compare two statistic counters by their string IDs. */ > > > > inline bool > > -stats_counter_hasher::equal (const value_type *c1, const compare_type *c2) > > +stats_counter_hasher::equal (const statistics_counter_t *c1, > > + const statistics_counter_t *c2) > > { > > return c1->val == c2->val && strcmp (c1->id, c2->id) == 0; > > } > > @@ -81,7 +83,7 @@ stats_counter_hasher::equal (const value_type *c1, const compare_type *c2) > > /* Free a statistics entry. */ > > > > inline void > > -stats_counter_hasher::remove (value_type *v) > > +stats_counter_hasher::remove (statistics_counter_t *v) > > { > > free (CONST_CAST (char *, v->id)); > > free (v); > > diff --git a/gcc/store-motion.c b/gcc/store-motion.c > > index 530766f..d621ec1 100644 > > --- a/gcc/store-motion.c > > +++ b/gcc/store-motion.c > > @@ -137,21 +137,21 @@ static struct edge_list *edge_list; > > > > struct st_expr_hasher : typed_noop_remove <st_expr> > > { > > - typedef st_expr value_type; > > - typedef st_expr compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef st_expr *value_type; > > + typedef st_expr *compare_type; > > + static inline hashval_t hash (const st_expr *); > > + static inline bool equal (const st_expr *, const st_expr *); > > }; > > > > inline hashval_t > > -st_expr_hasher::hash (const value_type *x) > > +st_expr_hasher::hash (const st_expr *x) > > { > > int do_not_record_p = 0; > > return hash_rtx (x->pattern, GET_MODE (x->pattern), &do_not_record_p, NULL, false); > > } > > > > inline bool > > -st_expr_hasher::equal (const value_type *ptr1, const compare_type *ptr2) > > +st_expr_hasher::equal (const st_expr *ptr1, const st_expr *ptr2) > > { > > return exp_equiv_p (ptr1->pattern, ptr2->pattern, 0, true); > > } > > diff --git a/gcc/trans-mem.c b/gcc/trans-mem.c > > index 078c2da..d6cbd76 100644 > > --- a/gcc/trans-mem.c > > +++ b/gcc/trans-mem.c > > @@ -974,23 +974,23 @@ typedef struct tm_log_entry > > > > struct log_entry_hasher > > { > > - typedef tm_log_entry value_type; > > - typedef tm_log_entry compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > - static inline void remove (value_type *); > > + typedef tm_log_entry *value_type; > > + typedef tm_log_entry *compare_type; > > + static inline hashval_t hash (const tm_log_entry *); > > + static inline bool equal (const tm_log_entry *, const tm_log_entry *); > > + static inline void remove (tm_log_entry *); > > }; > > > > /* Htab support. Return hash value for a `tm_log_entry'. */ > > inline hashval_t > > -log_entry_hasher::hash (const value_type *log) > > +log_entry_hasher::hash (const tm_log_entry *log) > > { > > return iterative_hash_expr (log->addr, 0); > > } > > > > /* Htab support. Return true if two log entries are the same. */ > > inline bool > > -log_entry_hasher::equal (const value_type *log1, const compare_type *log2) > > +log_entry_hasher::equal (const tm_log_entry *log1, const tm_log_entry *log2) > > { > > /* FIXME: > > > > @@ -1016,7 +1016,7 @@ log_entry_hasher::equal (const value_type *log1, const compare_type *log2) > > > > /* Htab support. Free one tm_log_entry. */ > > inline void > > -log_entry_hasher::remove (value_type *lp) > > +log_entry_hasher::remove (tm_log_entry *lp) > > { > > lp->stmts.release (); > > free (lp); > > @@ -1049,20 +1049,20 @@ typedef struct tm_new_mem_map > > > > struct tm_mem_map_hasher : typed_free_remove <tm_new_mem_map_t> > > { > > - typedef tm_new_mem_map_t value_type; > > - typedef tm_new_mem_map_t compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef tm_new_mem_map_t *value_type; > > + typedef tm_new_mem_map_t *compare_type; > > + static inline hashval_t hash (const tm_new_mem_map_t *); > > + static inline bool equal (const tm_new_mem_map_t *, const tm_new_mem_map_t *); > > }; > > > > inline hashval_t > > -tm_mem_map_hasher::hash (const value_type *v) > > +tm_mem_map_hasher::hash (const tm_new_mem_map_t *v) > > { > > return (intptr_t)v->val >> 4; > > } > > > > inline bool > > -tm_mem_map_hasher::equal (const value_type *v, const compare_type *c) > > +tm_mem_map_hasher::equal (const tm_new_mem_map_t *v, const tm_new_mem_map_t *c) > > { > > return v->val == c->val; > > } > > @@ -3350,15 +3350,15 @@ typedef struct tm_memop > > > > struct tm_memop_hasher : typed_free_remove <tm_memop> > > { > > - typedef tm_memop value_type; > > - typedef tm_memop compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef tm_memop *value_type; > > + typedef tm_memop *compare_type; > > + static inline hashval_t hash (const tm_memop *); > > + static inline bool equal (const tm_memop *, const tm_memop *); > > }; > > > > /* Htab support. Return a hash value for a `tm_memop'. */ > > inline hashval_t > > -tm_memop_hasher::hash (const value_type *mem) > > +tm_memop_hasher::hash (const tm_memop *mem) > > { > > tree addr = mem->addr; > > /* We drill down to the SSA_NAME/DECL for the hash, but equality is > > @@ -3370,7 +3370,7 @@ tm_memop_hasher::hash (const value_type *mem) > > > > /* Htab support. Return true if two tm_memop's are the same. */ > > inline bool > > -tm_memop_hasher::equal (const value_type *mem1, const compare_type *mem2) > > +tm_memop_hasher::equal (const tm_memop *mem1, const tm_memop *mem2) > > { > > return operand_equal_p (mem1->addr, mem2->addr, 0); > > } > > diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c > > index 64bdc92..c03dfed 100644 > > --- a/gcc/tree-cfg.c > > +++ b/gcc/tree-cfg.c > > @@ -148,17 +148,18 @@ struct locus_discrim_map > > > > struct locus_discrim_hasher : typed_free_remove <locus_discrim_map> > > { > > - typedef locus_discrim_map value_type; > > - typedef locus_discrim_map compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef locus_discrim_map *value_type; > > + typedef locus_discrim_map *compare_type; > > + static inline hashval_t hash (const locus_discrim_map *); > > + static inline bool equal (const locus_discrim_map *, > > + const locus_discrim_map *); > > }; > > > > /* Trivial hash function for a location_t. ITEM is a pointer to > > a hash table entry that maps a location_t to a discriminator. */ > > > > inline hashval_t > > -locus_discrim_hasher::hash (const value_type *item) > > +locus_discrim_hasher::hash (const locus_discrim_map *item) > > { > > return LOCATION_LINE (item->locus); > > } > > @@ -167,7 +168,8 @@ locus_discrim_hasher::hash (const value_type *item) > > point to the two hash table entries to compare. */ > > > > inline bool > > -locus_discrim_hasher::equal (const value_type *a, const compare_type *b) > > +locus_discrim_hasher::equal (const locus_discrim_map *a, > > + const locus_discrim_map *b) > > { > > return LOCATION_LINE (a->locus) == LOCATION_LINE (b->locus); > > } > > diff --git a/gcc/tree-eh.c b/gcc/tree-eh.c > > index a111e9d..5d41cb4 100644 > > --- a/gcc/tree-eh.c > > +++ b/gcc/tree-eh.c > > @@ -214,20 +214,22 @@ struct finally_tree_node > > > > struct finally_tree_hasher : typed_free_remove <finally_tree_node> > > { > > - typedef finally_tree_node value_type; > > - typedef finally_tree_node compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef finally_tree_node *value_type; > > + typedef finally_tree_node *compare_type; > > + static inline hashval_t hash (const finally_tree_node *); > > + static inline bool equal (const finally_tree_node *, > > + const finally_tree_node *); > > }; > > > > inline hashval_t > > -finally_tree_hasher::hash (const value_type *v) > > +finally_tree_hasher::hash (const finally_tree_node *v) > > { > > return (intptr_t)v->child.t >> 4; > > } > > > > inline bool > > -finally_tree_hasher::equal (const value_type *v, const compare_type *c) > > +finally_tree_hasher::equal (const finally_tree_node *v, > > + const finally_tree_node *c) > > { > > return v->child.t == c->child.t; > > } > > diff --git a/gcc/tree-hasher.h b/gcc/tree-hasher.h > > index 35eb9b2..228e317 100644 > > --- a/gcc/tree-hasher.h > > +++ b/gcc/tree-hasher.h > > @@ -34,7 +34,6 @@ struct int_tree_hasher > > { > > typedef int_tree_map value_type; > > typedef int_tree_map compare_type; > > - typedef int store_values_directly; > > static inline hashval_t hash (const value_type &); > > static inline bool equal (const value_type &, const compare_type &); > > static bool is_deleted (const value_type &v) > > diff --git a/gcc/tree-into-ssa.c b/gcc/tree-into-ssa.c > > index 2589628..e8b55c1 100644 > > --- a/gcc/tree-into-ssa.c > > +++ b/gcc/tree-into-ssa.c > > @@ -232,7 +232,6 @@ struct var_info_hasher : typed_free_remove <var_info_d> > > { > > typedef var_info_d *value_type; > > typedef var_info_d *compare_type; > > - typedef int store_values_directly; > > static inline hashval_t hash (const value_type &); > > static inline bool equal (const value_type &, const compare_type &); > > }; > > diff --git a/gcc/tree-parloops.c b/gcc/tree-parloops.c > > index 62a6444..080d35e 100644 > > --- a/gcc/tree-parloops.c > > +++ b/gcc/tree-parloops.c > > @@ -228,22 +228,22 @@ struct reduction_info > > > > struct reduction_hasher : typed_free_remove <reduction_info> > > { > > - typedef reduction_info value_type; > > - typedef reduction_info compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef reduction_info *value_type; > > + typedef reduction_info *compare_type; > > + static inline hashval_t hash (const reduction_info *); > > + static inline bool equal (const reduction_info *, const reduction_info *); > > }; > > > > /* Equality and hash functions for hashtab code. */ > > > > inline bool > > -reduction_hasher::equal (const value_type *a, const compare_type *b) > > +reduction_hasher::equal (const reduction_info *a, const reduction_info *b) > > { > > return (a->reduc_phi == b->reduc_phi); > > } > > > > inline hashval_t > > -reduction_hasher::hash (const value_type *a) > > +reduction_hasher::hash (const reduction_info *a) > > { > > return a->reduc_version; > > } > > @@ -280,22 +280,22 @@ struct name_to_copy_elt > > > > struct name_to_copy_hasher : typed_free_remove <name_to_copy_elt> > > { > > - typedef name_to_copy_elt value_type; > > - typedef name_to_copy_elt compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef name_to_copy_elt *value_type; > > + typedef name_to_copy_elt *compare_type; > > + static inline hashval_t hash (const name_to_copy_elt *); > > + static inline bool equal (const name_to_copy_elt *, const name_to_copy_elt *); > > }; > > > > /* Equality and hash functions for hashtab code. */ > > > > inline bool > > -name_to_copy_hasher::equal (const value_type *a, const compare_type *b) > > +name_to_copy_hasher::equal (const name_to_copy_elt *a, const name_to_copy_elt *b) > > { > > return a->version == b->version; > > } > > > > inline hashval_t > > -name_to_copy_hasher::hash (const value_type *a) > > +name_to_copy_hasher::hash (const name_to_copy_elt *a) > > { > > return (hashval_t) a->version; > > } > > diff --git a/gcc/tree-sra.c b/gcc/tree-sra.c > > index 6adee70..4b0d2a8 100644 > > --- a/gcc/tree-sra.c > > +++ b/gcc/tree-sra.c > > @@ -327,16 +327,16 @@ static hash_map<tree, auto_vec<access_p> > *base_access_vec; > > > > struct uid_decl_hasher : typed_noop_remove <tree_node> > > { > > - typedef tree_node value_type; > > - typedef tree_node compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef tree_node *value_type; > > + typedef tree_node *compare_type; > > + static inline hashval_t hash (const tree_node *); > > + static inline bool equal (const tree_node *, const tree_node *); > > }; > > > > /* Hash a tree in a uid_decl_map. */ > > > > inline hashval_t > > -uid_decl_hasher::hash (const value_type *item) > > +uid_decl_hasher::hash (const tree_node *item) > > { > > return item->decl_minimal.uid; > > } > > @@ -344,7 +344,7 @@ uid_decl_hasher::hash (const value_type *item) > > /* Return true if the DECL_UID in both trees are equal. */ > > > > inline bool > > -uid_decl_hasher::equal (const value_type *a, const compare_type *b) > > +uid_decl_hasher::equal (const tree_node *a, const tree_node *b) > > { > > return (a->decl_minimal.uid == b->decl_minimal.uid); > > } > > diff --git a/gcc/tree-ssa-coalesce.c b/gcc/tree-ssa-coalesce.c > > index 1afeefe..eeac5a4 100644 > > --- a/gcc/tree-ssa-coalesce.c > > +++ b/gcc/tree-ssa-coalesce.c > > @@ -81,16 +81,16 @@ typedef const struct coalesce_pair *const_coalesce_pair_p; > > > > struct coalesce_pair_hasher : typed_noop_remove <coalesce_pair> > > { > > - typedef coalesce_pair value_type; > > - typedef coalesce_pair compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef coalesce_pair *value_type; > > + typedef coalesce_pair *compare_type; > > + static inline hashval_t hash (const coalesce_pair *); > > + static inline bool equal (const coalesce_pair *, const coalesce_pair *); > > }; > > > > /* Hash function for coalesce list. Calculate hash for PAIR. */ > > > > inline hashval_t > > -coalesce_pair_hasher::hash (const value_type *pair) > > +coalesce_pair_hasher::hash (const coalesce_pair *pair) > > { > > hashval_t a = (hashval_t)(pair->first_element); > > hashval_t b = (hashval_t)(pair->second_element); > > @@ -102,7 +102,7 @@ coalesce_pair_hasher::hash (const value_type *pair) > > returning TRUE if the two pairs are equivalent. */ > > > > inline bool > > -coalesce_pair_hasher::equal (const value_type *p1, const compare_type *p2) > > +coalesce_pair_hasher::equal (const coalesce_pair *p1, const coalesce_pair *p2) > > { > > return (p1->first_element == p2->first_element > > && p1->second_element == p2->second_element); > > @@ -1253,10 +1253,10 @@ coalesce_partitions (var_map map, ssa_conflicts_p graph, coalesce_list_p cl, > > > > struct ssa_name_var_hash : typed_noop_remove <tree_node> > > { > > - typedef union tree_node value_type; > > - typedef union tree_node compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline int equal (const value_type *, const compare_type *); > > + typedef union tree_node *value_type; > > + typedef union tree_node *compare_type; > > + static inline hashval_t hash (const tree_node *); > > + static inline int equal (const tree_node *, const tree_node *); > > }; > > > > inline hashval_t > > @@ -1266,7 +1266,7 @@ ssa_name_var_hash::hash (const_tree n) > > } > > > > inline int > > -ssa_name_var_hash::equal (const value_type *n1, const compare_type *n2) > > +ssa_name_var_hash::equal (const tree_node *n1, const tree_node *n2) > > { > > return SSA_NAME_VAR (n1) == SSA_NAME_VAR (n2); > > } > > diff --git a/gcc/tree-ssa-dom.c b/gcc/tree-ssa-dom.c > > index 907fa97..c526b58 100644 > > --- a/gcc/tree-ssa-dom.c > > +++ b/gcc/tree-ssa-dom.c > > @@ -182,7 +182,6 @@ struct expr_elt_hasher > > { > > typedef expr_hash_elt *value_type; > > typedef expr_hash_elt *compare_type; > > - typedef int store_values_directly; > > static inline hashval_t hash (const value_type &); > > static inline bool equal (const value_type &, const compare_type &); > > static inline void remove (value_type &); > > diff --git a/gcc/tree-ssa-live.c b/gcc/tree-ssa-live.c > > index df90229..2c7c072 100644 > > --- a/gcc/tree-ssa-live.c > > +++ b/gcc/tree-ssa-live.c > > @@ -104,20 +104,20 @@ static void verify_live_on_entry (tree_live_info_p); > > > > struct tree_int_map_hasher : typed_noop_remove <tree_int_map> > > { > > - typedef tree_int_map value_type; > > - typedef tree_int_map compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef tree_int_map *value_type; > > + typedef tree_int_map *compare_type; > > + static inline hashval_t hash (const tree_int_map *); > > + static inline bool equal (const tree_int_map *, const tree_int_map *); > > }; > > > > inline hashval_t > > -tree_int_map_hasher::hash (const value_type *v) > > +tree_int_map_hasher::hash (const tree_int_map *v) > > { > > return tree_map_base_hash (v); > > } > > > > inline bool > > -tree_int_map_hasher::equal (const value_type *v, const compare_type *c) > > +tree_int_map_hasher::equal (const tree_int_map *v, const tree_int_map *c) > > { > > return tree_int_map_eq (v, c); > > } > > diff --git a/gcc/tree-ssa-loop-im.c b/gcc/tree-ssa-loop-im.c > > index 9aba79b..11fc699 100644 > > --- a/gcc/tree-ssa-loop-im.c > > +++ b/gcc/tree-ssa-loop-im.c > > @@ -172,16 +172,16 @@ typedef struct im_mem_ref > > > > struct mem_ref_hasher : typed_noop_remove <im_mem_ref> > > { > > - typedef im_mem_ref value_type; > > - typedef tree_node compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef im_mem_ref *value_type; > > + typedef tree_node *compare_type; > > + static inline hashval_t hash (const im_mem_ref *); > > + static inline bool equal (const im_mem_ref *, const tree_node *); > > }; > > > > /* A hash function for struct im_mem_ref object OBJ. */ > > > > inline hashval_t > > -mem_ref_hasher::hash (const value_type *mem) > > +mem_ref_hasher::hash (const im_mem_ref *mem) > > { > > return mem->hash; > > } > > @@ -190,7 +190,7 @@ mem_ref_hasher::hash (const value_type *mem) > > memory reference OBJ2. */ > > > > inline bool > > -mem_ref_hasher::equal (const value_type *mem1, const compare_type *obj2) > > +mem_ref_hasher::equal (const im_mem_ref *mem1, const tree_node *obj2) > > { > > return operand_equal_p (mem1->mem.ref, (const_tree) obj2, 0); > > } > > diff --git a/gcc/tree-ssa-loop-ivopts.c b/gcc/tree-ssa-loop-ivopts.c > > index 6c96430..d71e3a4 100644 > > --- a/gcc/tree-ssa-loop-ivopts.c > > +++ b/gcc/tree-ssa-loop-ivopts.c > > @@ -292,16 +292,16 @@ typedef struct iv_cand *iv_cand_p; > > > > struct iv_inv_expr_hasher : typed_free_remove <iv_inv_expr_ent> > > { > > - typedef iv_inv_expr_ent value_type; > > - typedef iv_inv_expr_ent compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef iv_inv_expr_ent *value_type; > > + typedef iv_inv_expr_ent *compare_type; > > + static inline hashval_t hash (const iv_inv_expr_ent *); > > + static inline bool equal (const iv_inv_expr_ent *, const iv_inv_expr_ent *); > > }; > > > > /* Hash function for loop invariant expressions. */ > > > > inline hashval_t > > -iv_inv_expr_hasher::hash (const value_type *expr) > > +iv_inv_expr_hasher::hash (const iv_inv_expr_ent *expr) > > { > > return expr->hash; > > } > > @@ -309,7 +309,8 @@ iv_inv_expr_hasher::hash (const value_type *expr) > > /* Hash table equality function for expressions. */ > > > > inline bool > > -iv_inv_expr_hasher::equal (const value_type *expr1, const compare_type *expr2) > > +iv_inv_expr_hasher::equal (const iv_inv_expr_ent *expr1, > > + const iv_inv_expr_ent *expr2) > > { > > return expr1->hash == expr2->hash > > && operand_equal_p (expr1->expr, expr2->expr, 0); > > diff --git a/gcc/tree-ssa-phiopt.c b/gcc/tree-ssa-phiopt.c > > index 14a7122..7c846c2 100644 > > --- a/gcc/tree-ssa-phiopt.c > > +++ b/gcc/tree-ssa-phiopt.c > > @@ -1332,10 +1332,10 @@ struct name_to_bb > > > > struct ssa_names_hasher : typed_free_remove <name_to_bb> > > { > > - typedef name_to_bb value_type; > > - typedef name_to_bb compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef name_to_bb *value_type; > > + typedef name_to_bb *compare_type; > > + static inline hashval_t hash (const name_to_bb *); > > + static inline bool equal (const name_to_bb *, const name_to_bb *); > > }; > > > > /* Used for quick clearing of the hash-table when we see calls. > > @@ -1345,7 +1345,7 @@ static unsigned int nt_call_phase; > > /* The hash function. */ > > > > inline hashval_t > > -ssa_names_hasher::hash (const value_type *n) > > +ssa_names_hasher::hash (const name_to_bb *n) > > { > > return n->ssa_name_ver ^ (((hashval_t) n->store) << 31) > > ^ (n->offset << 6) ^ (n->size << 3); > > @@ -1354,7 +1354,7 @@ ssa_names_hasher::hash (const value_type *n) > > /* The equality function of *P1 and *P2. */ > > > > inline bool > > -ssa_names_hasher::equal (const value_type *n1, const compare_type *n2) > > +ssa_names_hasher::equal (const name_to_bb *n1, const name_to_bb *n2) > > { > > return n1->ssa_name_ver == n2->ssa_name_ver > > && n1->store == n2->store > > diff --git a/gcc/tree-ssa-pre.c b/gcc/tree-ssa-pre.c > > index c985e79..d857d84 100644 > > --- a/gcc/tree-ssa-pre.c > > +++ b/gcc/tree-ssa-pre.c > > @@ -228,8 +228,8 @@ typedef struct pre_expr_d : typed_noop_remove <pre_expr_d> > > pre_expr_union u; > > > > /* hash_table support. */ > > - typedef pre_expr_d value_type; > > - typedef pre_expr_d compare_type; > > + typedef pre_expr_d *value_type; > > + typedef pre_expr_d *compare_type; > > static inline hashval_t hash (const pre_expr_d *); > > static inline int equal (const pre_expr_d *, const pre_expr_d *); > > } *pre_expr; > > @@ -242,7 +242,7 @@ typedef struct pre_expr_d : typed_noop_remove <pre_expr_d> > > /* Compare E1 and E1 for equality. */ > > > > inline int > > -pre_expr_d::equal (const value_type *e1, const compare_type *e2) > > +pre_expr_d::equal (const pre_expr_d *e1, const pre_expr_d *e2) > > { > > if (e1->kind != e2->kind) > > return false; > > @@ -267,7 +267,7 @@ pre_expr_d::equal (const value_type *e1, const compare_type *e2) > > /* Hash E. */ > > > > inline hashval_t > > -pre_expr_d::hash (const value_type *e) > > +pre_expr_d::hash (const pre_expr_d *e) > > { > > switch (e->kind) > > { > > @@ -547,10 +547,10 @@ typedef struct expr_pred_trans_d : typed_free_remove<expr_pred_trans_d> > > hashval_t hashcode; > > > > /* hash_table support. */ > > - typedef expr_pred_trans_d value_type; > > - typedef expr_pred_trans_d compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline int equal (const value_type *, const compare_type *); > > + typedef expr_pred_trans_d *value_type; > > + typedef expr_pred_trans_d *compare_type; > > + static inline hashval_t hash (const expr_pred_trans_d *); > > + static inline int equal (const expr_pred_trans_d *, const expr_pred_trans_d *); > > } *expr_pred_trans_t; > > typedef const struct expr_pred_trans_d *const_expr_pred_trans_t; > > > > @@ -561,8 +561,8 @@ expr_pred_trans_d::hash (const expr_pred_trans_d *e) > > } > > > > inline int > > -expr_pred_trans_d::equal (const value_type *ve1, > > - const compare_type *ve2) > > +expr_pred_trans_d::equal (const expr_pred_trans_d *ve1, > > + const expr_pred_trans_d *ve2) > > { > > basic_block b1 = ve1->pred; > > basic_block b2 = ve2->pred; > > diff --git a/gcc/tree-ssa-reassoc.c b/gcc/tree-ssa-reassoc.c > > index 77640e5..ae9d631 100644 > > --- a/gcc/tree-ssa-reassoc.c > > +++ b/gcc/tree-ssa-reassoc.c > > @@ -1061,7 +1061,6 @@ struct oecount_hasher > > { > > typedef int value_type; > > typedef int compare_type; > > - typedef int store_values_directly; > > static inline hashval_t hash (const value_type &); > > static inline bool equal (const value_type &, const compare_type &); > > static bool is_deleted (int &v) { return v == 1; } > > diff --git a/gcc/tree-ssa-sccvn.c b/gcc/tree-ssa-sccvn.c > > index 46ce285..c6a16bc 100644 > > --- a/gcc/tree-ssa-sccvn.c > > +++ b/gcc/tree-ssa-sccvn.c > > @@ -148,16 +148,16 @@ along with GCC; see the file COPYING3. If not see > > > > struct vn_nary_op_hasher : typed_noop_remove <vn_nary_op_s> > > { > > - typedef vn_nary_op_s value_type; > > - typedef vn_nary_op_s compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef vn_nary_op_s *value_type; > > + typedef vn_nary_op_s *compare_type; > > + static inline hashval_t hash (const vn_nary_op_s *); > > + static inline bool equal (const vn_nary_op_s *, const vn_nary_op_s *); > > }; > > > > /* Return the computed hashcode for nary operation P1. */ > > > > inline hashval_t > > -vn_nary_op_hasher::hash (const value_type *vno1) > > +vn_nary_op_hasher::hash (const vn_nary_op_s *vno1) > > { > > return vno1->hashcode; > > } > > @@ -166,7 +166,7 @@ vn_nary_op_hasher::hash (const value_type *vno1) > > equivalent. */ > > > > inline bool > > -vn_nary_op_hasher::equal (const value_type *vno1, const compare_type *vno2) > > +vn_nary_op_hasher::equal (const vn_nary_op_s *vno1, const vn_nary_op_s *vno2) > > { > > return vn_nary_op_eq (vno1, vno2); > > } > > @@ -182,17 +182,17 @@ vn_phi_eq (const_vn_phi_t const vp1, const_vn_phi_t const vp2); > > > > struct vn_phi_hasher > > { > > - typedef vn_phi_s value_type; > > - typedef vn_phi_s compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > - static inline void remove (value_type *); > > + typedef vn_phi_s *value_type; > > + typedef vn_phi_s *compare_type; > > + static inline hashval_t hash (const vn_phi_s *); > > + static inline bool equal (const vn_phi_s *, const vn_phi_s *); > > + static inline void remove (vn_phi_s *); > > }; > > > > /* Return the computed hashcode for phi operation P1. */ > > > > inline hashval_t > > -vn_phi_hasher::hash (const value_type *vp1) > > +vn_phi_hasher::hash (const vn_phi_s *vp1) > > { > > return vp1->hashcode; > > } > > @@ -200,7 +200,7 @@ vn_phi_hasher::hash (const value_type *vp1) > > /* Compare two phi entries for equality, ignoring VN_TOP arguments. */ > > > > inline bool > > -vn_phi_hasher::equal (const value_type *vp1, const compare_type *vp2) > > +vn_phi_hasher::equal (const vn_phi_s *vp1, const vn_phi_s *vp2) > > { > > return vn_phi_eq (vp1, vp2); > > } > > @@ -208,7 +208,7 @@ vn_phi_hasher::equal (const value_type *vp1, const compare_type *vp2) > > /* Free a phi operation structure VP. */ > > > > inline void > > -vn_phi_hasher::remove (value_type *phi) > > +vn_phi_hasher::remove (vn_phi_s *phi) > > { > > phi->phiargs.release (); > > } > > @@ -250,29 +250,29 @@ free_reference (vn_reference_s *vr) > > > > struct vn_reference_hasher > > { > > - typedef vn_reference_s value_type; > > - typedef vn_reference_s compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > - static inline void remove (value_type *); > > + typedef vn_reference_s *value_type; > > + typedef vn_reference_s *compare_type; > > + static inline hashval_t hash (const vn_reference_s *); > > + static inline bool equal (const vn_reference_s *, const vn_reference_s *); > > + static inline void remove (vn_reference_s *); > > }; > > > > /* Return the hashcode for a given reference operation P1. */ > > > > inline hashval_t > > -vn_reference_hasher::hash (const value_type *vr1) > > +vn_reference_hasher::hash (const vn_reference_s *vr1) > > { > > return vr1->hashcode; > > } > > > > inline bool > > -vn_reference_hasher::equal (const value_type *v, const compare_type *c) > > +vn_reference_hasher::equal (const vn_reference_s *v, const vn_reference_s *c) > > { > > return vn_reference_eq (v, c); > > } > > > > inline void > > -vn_reference_hasher::remove (value_type *v) > > +vn_reference_hasher::remove (vn_reference_s *v) > > { > > free_reference (v); > > } > > @@ -298,16 +298,16 @@ typedef struct vn_tables_s > > > > struct vn_constant_hasher : typed_free_remove <vn_constant_s> > > { > > - typedef vn_constant_s value_type; > > - typedef vn_constant_s compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef vn_constant_s *value_type; > > + typedef vn_constant_s *compare_type; > > + static inline hashval_t hash (const vn_constant_s *); > > + static inline bool equal (const vn_constant_s *, const vn_constant_s *); > > }; > > > > /* Hash table hash function for vn_constant_t. */ > > > > inline hashval_t > > -vn_constant_hasher::hash (const value_type *vc1) > > +vn_constant_hasher::hash (const vn_constant_s *vc1) > > { > > return vc1->hashcode; > > } > > @@ -315,7 +315,7 @@ vn_constant_hasher::hash (const value_type *vc1) > > /* Hash table equality function for vn_constant_t. */ > > > > inline bool > > -vn_constant_hasher::equal (const value_type *vc1, const compare_type *vc2) > > +vn_constant_hasher::equal (const vn_constant_s *vc1, const vn_constant_s *vc2) > > { > > if (vc1->hashcode != vc2->hashcode) > > return false; > > diff --git a/gcc/tree-ssa-structalias.c b/gcc/tree-ssa-structalias.c > > index fd0f535..d6a9f67 100644 > > --- a/gcc/tree-ssa-structalias.c > > +++ b/gcc/tree-ssa-structalias.c > > @@ -1940,16 +1940,17 @@ typedef const struct equiv_class_label *const_equiv_class_label_t; > > > > struct equiv_class_hasher : typed_free_remove <equiv_class_label> > > { > > - typedef equiv_class_label value_type; > > - typedef equiv_class_label compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef equiv_class_label *value_type; > > + typedef equiv_class_label *compare_type; > > + static inline hashval_t hash (const equiv_class_label *); > > + static inline bool equal (const equiv_class_label *, > > + const equiv_class_label *); > > }; > > > > /* Hash function for a equiv_class_label_t */ > > > > inline hashval_t > > -equiv_class_hasher::hash (const value_type *ecl) > > +equiv_class_hasher::hash (const equiv_class_label *ecl) > > { > > return ecl->hashcode; > > } > > @@ -1957,7 +1958,8 @@ equiv_class_hasher::hash (const value_type *ecl) > > /* Equality function for two equiv_class_label_t's. */ > > > > inline bool > > -equiv_class_hasher::equal (const value_type *eql1, const compare_type *eql2) > > +equiv_class_hasher::equal (const equiv_class_label *eql1, > > + const equiv_class_label *eql2) > > { > > return (eql1->hashcode == eql2->hashcode > > && bitmap_equal_p (eql1->labels, eql2->labels)); > > @@ -5963,16 +5965,17 @@ typedef const struct shared_bitmap_info *const_shared_bitmap_info_t; > > > > struct shared_bitmap_hasher : typed_free_remove <shared_bitmap_info> > > { > > - typedef shared_bitmap_info value_type; > > - typedef shared_bitmap_info compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef shared_bitmap_info *value_type; > > + typedef shared_bitmap_info *compare_type; > > + static inline hashval_t hash (const shared_bitmap_info *); > > + static inline bool equal (const shared_bitmap_info *, > > + const shared_bitmap_info *); > > }; > > > > /* Hash function for a shared_bitmap_info_t */ > > > > inline hashval_t > > -shared_bitmap_hasher::hash (const value_type *bi) > > +shared_bitmap_hasher::hash (const shared_bitmap_info *bi) > > { > > return bi->hashcode; > > } > > @@ -5980,7 +5983,8 @@ shared_bitmap_hasher::hash (const value_type *bi) > > /* Equality function for two shared_bitmap_info_t's. */ > > > > inline bool > > -shared_bitmap_hasher::equal (const value_type *sbi1, const compare_type *sbi2) > > +shared_bitmap_hasher::equal (const shared_bitmap_info *sbi1, > > + const shared_bitmap_info *sbi2) > > { > > return bitmap_equal_p (sbi1->pt_vars, sbi2->pt_vars); > > } > > diff --git a/gcc/tree-ssa-tail-merge.c b/gcc/tree-ssa-tail-merge.c > > index 2c48cb6..4afe94e 100644 > > --- a/gcc/tree-ssa-tail-merge.c > > +++ b/gcc/tree-ssa-tail-merge.c > > @@ -260,11 +260,11 @@ struct same_succ_def > > hashval_t hashval; > > > > /* hash_table support. */ > > - typedef same_succ_def value_type; > > - typedef same_succ_def compare_type; > > - static inline hashval_t hash (const value_type *); > > - static int equal (const value_type *, const compare_type *); > > - static void remove (value_type *); > > + typedef same_succ_def *value_type; > > + typedef same_succ_def *compare_type; > > + static inline hashval_t hash (const same_succ_def *); > > + static int equal (const same_succ_def *, const same_succ_def *); > > + static void remove (same_succ_def *); > > }; > > typedef struct same_succ_def *same_succ; > > typedef const struct same_succ_def *const_same_succ; > > @@ -272,7 +272,7 @@ typedef const struct same_succ_def *const_same_succ; > > /* hash routine for hash_table support, returns hashval of E. */ > > > > inline hashval_t > > -same_succ_def::hash (const value_type *e) > > +same_succ_def::hash (const same_succ_def *e) > > { > > return e->hashval; > > } > > @@ -568,7 +568,7 @@ inverse_flags (const_same_succ e1, const_same_succ e2) > > /* Compares SAME_SUCCs E1 and E2. */ > > > > int > > -same_succ_def::equal (const value_type *e1, const compare_type *e2) > > +same_succ_def::equal (const same_succ_def *e1, const same_succ_def *e2) > > { > > unsigned int i, first1, first2; > > gimple_stmt_iterator gsi1, gsi2; > > diff --git a/gcc/tree-ssa-threadupdate.c b/gcc/tree-ssa-threadupdate.c > > index 610e807..709b16e 100644 > > --- a/gcc/tree-ssa-threadupdate.c > > +++ b/gcc/tree-ssa-threadupdate.c > > @@ -160,10 +160,10 @@ struct redirection_data : typed_free_remove<redirection_data> > > struct el *incoming_edges; > > > > /* hash_table support. */ > > - typedef redirection_data value_type; > > - typedef redirection_data compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline int equal (const value_type *, const compare_type *); > > + typedef redirection_data *value_type; > > + typedef redirection_data *compare_type; > > + static inline hashval_t hash (const redirection_data *); > > + static inline int equal (const redirection_data *, const redirection_data *); > > }; > > > > /* Dump a jump threading path, including annotations about each > > @@ -209,7 +209,7 @@ dump_jump_thread_path (FILE *dump_file, vec<jump_thread_edge *> path, > > path. So hash on the block index of the final edge in the path. */ > > > > inline hashval_t > > -redirection_data::hash (const value_type *p) > > +redirection_data::hash (const redirection_data *p) > > { > > vec<jump_thread_edge *> *path = p->path; > > return path->last ()->e->dest->index; > > @@ -218,7 +218,7 @@ redirection_data::hash (const value_type *p) > > /* Given two hash table entries, return true if they have the same > > jump threading path. */ > > inline int > > -redirection_data::equal (const value_type *p1, const compare_type *p2) > > +redirection_data::equal (const redirection_data *p1, const redirection_data *p2) > > { > > vec<jump_thread_edge *> *path1 = p1->path; > > vec<jump_thread_edge *> *path2 = p2->path; > > diff --git a/gcc/tree-vectorizer.c b/gcc/tree-vectorizer.c > > index 415bffa..313e936 100644 > > --- a/gcc/tree-vectorizer.c > > +++ b/gcc/tree-vectorizer.c > > @@ -118,20 +118,20 @@ struct simduid_to_vf : typed_free_remove<simduid_to_vf> > > int vf; > > > > /* hash_table support. */ > > - typedef simduid_to_vf value_type; > > - typedef simduid_to_vf compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline int equal (const value_type *, const compare_type *); > > + typedef simduid_to_vf *value_type; > > + typedef simduid_to_vf *compare_type; > > + static inline hashval_t hash (const simduid_to_vf *); > > + static inline int equal (const simduid_to_vf *, const simduid_to_vf *); > > }; > > > > inline hashval_t > > -simduid_to_vf::hash (const value_type *p) > > +simduid_to_vf::hash (const simduid_to_vf *p) > > { > > return p->simduid; > > } > > > > inline int > > -simduid_to_vf::equal (const value_type *p1, const value_type *p2) > > +simduid_to_vf::equal (const simduid_to_vf *p1, const simduid_to_vf *p2) > > { > > return p1->simduid == p2->simduid; > > } > > @@ -154,20 +154,22 @@ struct simd_array_to_simduid : typed_free_remove<simd_array_to_simduid> > > unsigned int simduid; > > > > /* hash_table support. */ > > - typedef simd_array_to_simduid value_type; > > - typedef simd_array_to_simduid compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline int equal (const value_type *, const compare_type *); > > + typedef simd_array_to_simduid *value_type; > > + typedef simd_array_to_simduid *compare_type; > > + static inline hashval_t hash (const simd_array_to_simduid *); > > + static inline int equal (const simd_array_to_simduid *, > > + const simd_array_to_simduid *); > > }; > > > > inline hashval_t > > -simd_array_to_simduid::hash (const value_type *p) > > +simd_array_to_simduid::hash (const simd_array_to_simduid *p) > > { > > return DECL_UID (p->decl); > > } > > > > inline int > > -simd_array_to_simduid::equal (const value_type *p1, const value_type *p2) > > +simd_array_to_simduid::equal (const simd_array_to_simduid *p1, > > + const simd_array_to_simduid *p2) > > { > > return p1->decl == p2->decl; > > } > > diff --git a/gcc/tree-vectorizer.h b/gcc/tree-vectorizer.h > > index 66d592d..f22d6cf 100644 > > --- a/gcc/tree-vectorizer.h > > +++ b/gcc/tree-vectorizer.h > > @@ -220,20 +220,20 @@ typedef struct _vect_peel_extended_info > > > > struct peel_info_hasher : typed_free_remove <_vect_peel_info> > > { > > - typedef _vect_peel_info value_type; > > - typedef _vect_peel_info compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef _vect_peel_info *value_type; > > + typedef _vect_peel_info *compare_type; > > + static inline hashval_t hash (const _vect_peel_info *); > > + static inline bool equal (const _vect_peel_info *, const _vect_peel_info *); > > }; > > > > inline hashval_t > > -peel_info_hasher::hash (const value_type *peel_info) > > +peel_info_hasher::hash (const _vect_peel_info *peel_info) > > { > > return (hashval_t) peel_info->npeel; > > } > > > > inline bool > > -peel_info_hasher::equal (const value_type *a, const compare_type *b) > > +peel_info_hasher::equal (const _vect_peel_info *a, const _vect_peel_info *b) > > { > > return (a->npeel == b->npeel); > > } > > diff --git a/gcc/valtrack.h b/gcc/valtrack.h > > index 402fef9..b7b53f3 100644 > > --- a/gcc/valtrack.h > > +++ b/gcc/valtrack.h > > @@ -45,33 +45,35 @@ struct dead_debug_global_entry > > struct dead_debug_hash_descr > > { > > /* The hash table contains pointers to entries of this type. */ > > - typedef struct dead_debug_global_entry value_type; > > - typedef struct dead_debug_global_entry compare_type; > > + typedef struct dead_debug_global_entry *value_type; > > + typedef struct dead_debug_global_entry *compare_type; > > /* Hash on the pseudo number. */ > > - static inline hashval_t hash (const value_type *my); > > + static inline hashval_t hash (const dead_debug_global_entry *my); > > /* Entries are identical if they refer to the same pseudo. */ > > - static inline bool equal (const value_type *my, const compare_type *other); > > + static inline bool equal (const dead_debug_global_entry *my, > > + const dead_debug_global_entry *other); > > /* Release entries when they're removed. */ > > - static inline void remove (value_type *p); > > + static inline void remove (dead_debug_global_entry *p); > > }; > > > > /* Hash on the pseudo number. */ > > inline hashval_t > > -dead_debug_hash_descr::hash (const value_type *my) > > +dead_debug_hash_descr::hash (const dead_debug_global_entry *my) > > { > > return REGNO (my->reg); > > } > > > > /* Entries are identical if they refer to the same pseudo. */ > > inline bool > > -dead_debug_hash_descr::equal (const value_type *my, const compare_type *other) > > +dead_debug_hash_descr::equal (const dead_debug_global_entry *my, > > + const dead_debug_global_entry *other) > > { > > return my->reg == other->reg; > > } > > > > /* Release entries when they're removed. */ > > inline void > > -dead_debug_hash_descr::remove (value_type *p) > > +dead_debug_hash_descr::remove (dead_debug_global_entry *p) > > { > > XDELETE (p); > > } > > diff --git a/gcc/var-tracking.c b/gcc/var-tracking.c > > index 18eff20..685fcc38c 100644 > > --- a/gcc/var-tracking.c > > +++ b/gcc/var-tracking.c > > @@ -494,18 +494,18 @@ static void variable_htab_free (void *); > > > > struct variable_hasher > > { > > - typedef variable_def value_type; > > - typedef void compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > - static inline void remove (value_type *); > > + typedef variable_def *value_type; > > + typedef void *compare_type; > > + static inline hashval_t hash (const variable_def *); > > + static inline bool equal (const variable_def *, const void *); > > + static inline void remove (variable_def *); > > }; > > > > /* The hash function for variable_htab, computes the hash value > > from the declaration of variable X. */ > > > > inline hashval_t > > -variable_hasher::hash (const value_type *v) > > +variable_hasher::hash (const variable_def *v) > > { > > return dv_htab_hash (v->dv); > > } > > @@ -513,7 +513,7 @@ variable_hasher::hash (const value_type *v) > > /* Compare the declaration of variable X with declaration Y. */ > > > > inline bool > > -variable_hasher::equal (const value_type *v, const compare_type *y) > > +variable_hasher::equal (const variable_def *v, const void *y) > > { > > decl_or_value dv = CONST_CAST2 (decl_or_value, const void *, y); > > > > @@ -523,7 +523,7 @@ variable_hasher::equal (const value_type *v, const compare_type *y) > > /* Free the element of VARIABLE_HTAB (its type is struct variable_def). */ > > > > inline void > > -variable_hasher::remove (value_type *var) > > +variable_hasher::remove (variable_def *var) > > { > > variable_htab_free (var); > > } > > diff --git a/gcc/vtable-verify.c b/gcc/vtable-verify.c > > index 22b7b81..8ced835 100644 > > --- a/gcc/vtable-verify.c > > +++ b/gcc/vtable-verify.c > > @@ -268,14 +268,15 @@ vtbl_map_node_registration_insert (struct vtbl_map_node *node, > > /* Hashtable functions for vtable_registration hashtables. */ > > > > inline hashval_t > > -registration_hasher::hash (const value_type *p) > > +registration_hasher::hash (const vtable_registration *p) > > { > > const struct vtable_registration *n = (const struct vtable_registration *) p; > > return (hashval_t) (DECL_UID (n->vtable_decl)); > > } > > > > inline bool > > -registration_hasher::equal (const value_type *p1, const compare_type *p2) > > +registration_hasher::equal (const vtable_registration *p1, > > + const vtable_registration *p2) > > { > > const struct vtable_registration *n1 = > > (const struct vtable_registration *) p1; > > @@ -292,16 +293,16 @@ registration_hasher::equal (const value_type *p1, const compare_type *p2) > > > > struct vtbl_map_hasher : typed_noop_remove <struct vtbl_map_node> > > { > > - typedef struct vtbl_map_node value_type; > > - typedef struct vtbl_map_node compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef struct vtbl_map_node *value_type; > > + typedef struct vtbl_map_node *compare_type; > > + static inline hashval_t hash (const vtbl_map_node *); > > + static inline bool equal (const vtbl_map_node *, const vtbl_map_node *); > > }; > > > > /* Returns a hash code for P. */ > > > > inline hashval_t > > -vtbl_map_hasher::hash (const value_type *p) > > +vtbl_map_hasher::hash (const vtbl_map_node *p) > > { > > const struct vtbl_map_node n = *((const struct vtbl_map_node *) p); > > return (hashval_t) IDENTIFIER_HASH_VALUE (n.class_name); > > @@ -310,7 +311,7 @@ vtbl_map_hasher::hash (const value_type *p) > > /* Returns nonzero if P1 and P2 are equal. */ > > > > inline bool > > -vtbl_map_hasher::equal (const value_type *p1, const compare_type *p2) > > +vtbl_map_hasher::equal (const vtbl_map_node *p1, const vtbl_map_node *p2) > > { > > const struct vtbl_map_node n1 = *((const struct vtbl_map_node *) p1); > > const struct vtbl_map_node n2 = *((const struct vtbl_map_node *) p2); > > diff --git a/gcc/vtable-verify.h b/gcc/vtable-verify.h > > index b0169ad..6fb2b60 100644 > > --- a/gcc/vtable-verify.h > > +++ b/gcc/vtable-verify.h > > @@ -58,10 +58,11 @@ struct vtable_registration > > > > struct registration_hasher : typed_noop_remove <struct vtable_registration> > > { > > - typedef struct vtable_registration value_type; > > - typedef struct vtable_registration compare_type; > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + typedef struct vtable_registration *value_type; > > + typedef struct vtable_registration *compare_type; > > + static inline hashval_t hash (const vtable_registration *); > > + static inline bool equal (const vtable_registration *, > > + const vtable_registration *); > > }; > > > > typedef hash_table<registration_hasher> register_table_type; > > diff --git a/libcc1/plugin.cc b/libcc1/plugin.cc > > index c4caf05..74a7ec3 100644 > > --- a/libcc1/plugin.cc > > +++ b/libcc1/plugin.cc > > @@ -113,38 +113,38 @@ struct decl_addr_value > > > > struct decl_addr_hasher : typed_free_remove<decl_addr_value> > > { > > - typedef decl_addr_value value_type; > > - typedef decl_addr_value compare_type; > > + typedef decl_addr_value *value_type; > > + typedef decl_addr_value *compare_type; > > > > - static inline hashval_t hash (const value_type *); > > - static inline bool equal (const value_type *, const compare_type *); > > + static inline hashval_t hash (const decl_addr_value *); > > + static inline bool equal (const decl_addr_value *, const decl_addr_value *); > > }; > > > > inline hashval_t > > -decl_addr_hasher::hash (const value_type *e) > > +decl_addr_hasher::hash (const decl_addr_value *e) > > { > > return IDENTIFIER_HASH_VALUE (DECL_NAME (e->decl)); > > } > > > > inline bool > > -decl_addr_hasher::equal (const value_type *p1, const compare_type *p2) > > +decl_addr_hasher::equal (const decl_addr_value *p1, const decl_addr_value *p2) > > { > > return p1->decl == p2->decl; > > } > > > > > > > > -struct string_hasher : typed_noop_remove<char> > > +struct string_hasher : typed_noop_remove<const char> > > { > > - typedef char value_type; > > - typedef char compare_type; > > + typedef const char *value_type; > > + typedef const char *compare_type; > > > > - static inline hashval_t hash (const value_type *s) > > + static inline hashval_t hash (const char *s) > > { > > return htab_hash_string (s); > > } > > > > - static inline bool equal (const value_type *p1, const value_type *p2) > > + static inline bool equal (const char *p1, const char *p2) > > { > > return strcmp (p1, p2) == 0; > > } > > @@ -210,7 +210,7 @@ private: > > // Add a file name to FILE_NAMES and return the canonical copy. > > const char *intern_filename (const char *filename) > > { > > - char **slot = file_names.find_slot (filename, INSERT); > > + const char **slot = file_names.find_slot (filename, INSERT); > > if (*slot == NULL) > > { > > /* The file name must live as long as the line map, which > > -- > > 2.3.0.80.g18d0fec.dirty > >
diff --git a/gcc/asan.c b/gcc/asan.c index 9e4a629..7b70ee2 100644 --- a/gcc/asan.c +++ b/gcc/asan.c @@ -407,11 +407,11 @@ asan_mem_ref_get_end (const asan_mem_ref *ref, tree len) struct asan_mem_ref_hasher : typed_noop_remove <asan_mem_ref> { - typedef asan_mem_ref value_type; - typedef asan_mem_ref compare_type; + typedef asan_mem_ref *value_type; + typedef asan_mem_ref *compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + static inline hashval_t hash (const asan_mem_ref *); + static inline bool equal (const asan_mem_ref *, const asan_mem_ref *); }; /* Hash a memory reference. */ diff --git a/gcc/attribs.c b/gcc/attribs.c index c18bff2..7b7e2a9 100644 --- a/gcc/attribs.c +++ b/gcc/attribs.c @@ -67,21 +67,21 @@ substring_hash (const char *str, int l) struct attribute_hasher : typed_noop_remove <attribute_spec> { - typedef attribute_spec value_type; - typedef substring compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef attribute_spec *value_type; + typedef substring *compare_type; + static inline hashval_t hash (const attribute_spec *); + static inline bool equal (const attribute_spec *, const substring *); }; inline hashval_t -attribute_hasher::hash (const value_type *spec) +attribute_hasher::hash (const attribute_spec *spec) { const int l = strlen (spec->name); return substring_hash (spec->name, l); } inline bool -attribute_hasher::equal (const value_type *spec, const compare_type *str) +attribute_hasher::equal (const attribute_spec *spec, const substring *str) { return (strncmp (spec->name, str->str, str->length) == 0 && !spec->name[str->length]); diff --git a/gcc/bitmap.c b/gcc/bitmap.c index d43a39f..71d5b11 100644 --- a/gcc/bitmap.c +++ b/gcc/bitmap.c @@ -61,20 +61,20 @@ struct loc struct bitmap_desc_hasher : typed_noop_remove <bitmap_descriptor_d> { - typedef bitmap_descriptor_d value_type; - typedef loc compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef bitmap_descriptor_d *value_type; + typedef loc *compare_type; + static inline hashval_t hash (const bitmap_descriptor_d *); + static inline bool equal (const bitmap_descriptor_d *, const loc *); }; inline hashval_t -bitmap_desc_hasher::hash (const value_type *d) +bitmap_desc_hasher::hash (const bitmap_descriptor_d *d) { return htab_hash_pointer (d->file) + d->line; } inline bool -bitmap_desc_hasher::equal (const value_type *d, const compare_type *l) +bitmap_desc_hasher::equal (const bitmap_descriptor_d *d, const loc *l) { return d->file == l->file && d->function == l->function && d->line == l->line; } diff --git a/gcc/cfg.c b/gcc/cfg.c index d96be45..3074500 100644 --- a/gcc/cfg.c +++ b/gcc/cfg.c @@ -1039,21 +1039,22 @@ struct htab_bb_copy_original_entry struct bb_copy_hasher : typed_noop_remove <htab_bb_copy_original_entry> { - typedef htab_bb_copy_original_entry value_type; - typedef htab_bb_copy_original_entry compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *existing, - const compare_type * candidate); + typedef htab_bb_copy_original_entry *value_type; + typedef htab_bb_copy_original_entry *compare_type; + static inline hashval_t hash (const htab_bb_copy_original_entry *); + static inline bool equal (const htab_bb_copy_original_entry *existing, + const htab_bb_copy_original_entry * candidate); }; inline hashval_t -bb_copy_hasher::hash (const value_type *data) +bb_copy_hasher::hash (const htab_bb_copy_original_entry *data) { return data->index1; } inline bool -bb_copy_hasher::equal (const value_type *data, const compare_type *data2) +bb_copy_hasher::equal (const htab_bb_copy_original_entry *data, + const htab_bb_copy_original_entry *data2) { return data->index1 == data2->index1; } diff --git a/gcc/cgraph.h b/gcc/cgraph.h index cf8c7b6..29f65a8 100644 --- a/gcc/cgraph.h +++ b/gcc/cgraph.h @@ -1872,7 +1872,6 @@ struct asmname_hasher { typedef symtab_node *value_type; typedef const_tree compare_type; - typedef int store_values_directly; static hashval_t hash (symtab_node *n); static bool equal (symtab_node *n, const_tree t); diff --git a/gcc/config/arm/arm.c b/gcc/config/arm/arm.c index 0466399..6826c78 100644 --- a/gcc/config/arm/arm.c +++ b/gcc/config/arm/arm.c @@ -4897,21 +4897,21 @@ arm_function_value(const_tree type, const_tree func, struct libcall_hasher : typed_noop_remove <rtx_def> { - typedef rtx_def value_type; - typedef rtx_def compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); - static inline void remove (value_type *); + typedef const rtx_def *value_type; + typedef const rtx_def *compare_type; + static inline hashval_t hash (const rtx_def *); + static inline bool equal (const rtx_def *, const rtx_def *); + static inline void remove (rtx_def *); }; inline bool -libcall_hasher::equal (const value_type *p1, const compare_type *p2) +libcall_hasher::equal (const rtx_def *p1, const rtx_def *p2) { return rtx_equal_p (p1, p2); } inline hashval_t -libcall_hasher::hash (const value_type *p1) +libcall_hasher::hash (const rtx_def *p1) { return hash_rtx (p1, VOIDmode, NULL, NULL, FALSE); } diff --git a/gcc/config/i386/winnt.c b/gcc/config/i386/winnt.c index 14fd253..f61412f 100644 --- a/gcc/config/i386/winnt.c +++ b/gcc/config/i386/winnt.c @@ -738,15 +738,15 @@ i386_pe_record_stub (const char *name) struct wrapped_symbol_hasher : typed_noop_remove <char> { - typedef char value_type; - typedef char compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); - static inline void remove (value_type *); + typedef char *value_type; + typedef char *compare_type; + static inline hashval_t hash (const char *); + static inline bool equal (const char *, const char *); + static inline void remove (char *); }; inline hashval_t -wrapped_symbol_hasher::hash (const value_type *v) +wrapped_symbol_hasher::hash (const char *v) { return htab_hash_string (v); } @@ -754,7 +754,7 @@ wrapped_symbol_hasher::hash (const value_type *v) /* Hash table equality helper function. */ inline bool -wrapped_symbol_hasher::equal (const value_type *x, const compare_type *y) +wrapped_symbol_hasher::equal (const char *x, const char *y) { return !strcmp (x, y); } diff --git a/gcc/config/ia64/ia64.c b/gcc/config/ia64/ia64.c index 5132d2f..40e6ebe 100644 --- a/gcc/config/ia64/ia64.c +++ b/gcc/config/ia64/ia64.c @@ -8609,16 +8609,16 @@ finish_bundle_states (void) struct bundle_state_hasher : typed_noop_remove <bundle_state> { - typedef bundle_state value_type; - typedef bundle_state compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef bundle_state *value_type; + typedef bundle_state *compare_type; + static inline hashval_t hash (const bundle_state *); + static inline bool equal (const bundle_state *, const bundle_state *); }; /* The function returns hash of BUNDLE_STATE. */ inline hashval_t -bundle_state_hasher::hash (const value_type *state) +bundle_state_hasher::hash (const bundle_state *state) { unsigned result, i; @@ -8631,8 +8631,8 @@ bundle_state_hasher::hash (const value_type *state) /* The function returns nonzero if the bundle state keys are equal. */ inline bool -bundle_state_hasher::equal (const value_type *state1, - const compare_type *state2) +bundle_state_hasher::equal (const bundle_state *state1, + const bundle_state *state2) { return (state1->insn_num == state2->insn_num && memcmp (state1->dfa_state, state2->dfa_state, diff --git a/gcc/config/mips/mips.c b/gcc/config/mips/mips.c index 1733457..bf69850 100644 --- a/gcc/config/mips/mips.c +++ b/gcc/config/mips/mips.c @@ -16381,23 +16381,23 @@ mips_hash_base (rtx base) struct mips_lo_sum_offset_hasher : typed_free_remove <mips_lo_sum_offset> { - typedef mips_lo_sum_offset value_type; - typedef rtx_def compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef mips_lo_sum_offset *value_type; + typedef rtx_def *compare_type; + static inline hashval_t hash (const mips_lo_sum_offset *); + static inline bool equal (const mips_lo_sum_offset *, const rtx_def *); }; /* Hash-table callbacks for mips_lo_sum_offsets. */ inline hashval_t -mips_lo_sum_offset_hasher::hash (const value_type *entry) +mips_lo_sum_offset_hasher::hash (const mips_lo_sum_offset *entry) { return mips_hash_base (entry->base); } inline bool -mips_lo_sum_offset_hasher::equal (const value_type *entry, - const compare_type *value) +mips_lo_sum_offset_hasher::equal (const mips_lo_sum_offset *entry, + const rtx_def *value) { return rtx_equal_p (entry->base, value); } diff --git a/gcc/config/sol2.c b/gcc/config/sol2.c index d256776..d87c7b4 100644 --- a/gcc/config/sol2.c +++ b/gcc/config/sol2.c @@ -183,22 +183,22 @@ typedef struct comdat_entry struct comdat_entry_hasher : typed_noop_remove <comdat_entry> { - typedef comdat_entry value_type; - typedef comdat_entry compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); - static inline void remove (value_type *); + typedef comdat_entry *value_type; + typedef comdat_entry *compare_type; + static inline hashval_t hash (const comdat_entry *); + static inline bool equal (const comdat_entry *, const comdat_entry *); + static inline void remove (comdat_entry *); }; inline hashval_t -comdat_entry_hasher::hash (const value_type *entry) +comdat_entry_hasher::hash (const comdat_entry *entry) { return htab_hash_string (entry->sig); } inline bool -comdat_entry_hasher::equal (const value_type *entry1, - const compare_type *entry2) +comdat_entry_hasher::equal (const comdat_entry *entry1, + const comdat_entry *entry2) { return strcmp (entry1->sig, entry2->sig) == 0; } diff --git a/gcc/coverage.c b/gcc/coverage.c index 661e441..e1d81ff 100644 --- a/gcc/coverage.c +++ b/gcc/coverage.c @@ -114,11 +114,11 @@ typedef struct counts_entry struct gcov_ctr_summary summary; /* hash_table support. */ - typedef counts_entry value_type; - typedef counts_entry compare_type; - static inline hashval_t hash (const value_type *); - static int equal (const value_type *, const compare_type *); - static void remove (value_type *); + typedef counts_entry *value_type; + typedef counts_entry *compare_type; + static inline hashval_t hash (const counts_entry *); + static int equal (const counts_entry *, const counts_entry *); + static void remove (counts_entry *); } counts_entry_t; static GTY(()) struct coverage_data *functions_head = 0; @@ -197,20 +197,19 @@ get_gcov_unsigned_t (void) } inline hashval_t -counts_entry::hash (const value_type *entry) +counts_entry::hash (const counts_entry *entry) { return entry->ident * GCOV_COUNTERS + entry->ctr; } inline int -counts_entry::equal (const value_type *entry1, - const compare_type *entry2) +counts_entry::equal (const counts_entry *entry1, const counts_entry *entry2) { return entry1->ident == entry2->ident && entry1->ctr == entry2->ctr; } inline void -counts_entry::remove (value_type *entry) +counts_entry::remove (counts_entry *entry) { free (entry->counts); free (entry); diff --git a/gcc/cselib.c b/gcc/cselib.c index d6ccbfb..30845ed 100644 --- a/gcc/cselib.c +++ b/gcc/cselib.c @@ -102,8 +102,8 @@ static rtx cselib_expand_value_rtx_1 (rtx, struct expand_value_data *, int); struct cselib_hasher : typed_noop_remove <cselib_val> { - typedef cselib_val value_type; - struct compare_type { + typedef cselib_val *value_type; + struct key { /* The rtx value and its mode (needed separately for constant integers). */ machine_mode mode; @@ -111,8 +111,9 @@ struct cselib_hasher : typed_noop_remove <cselib_val> /* The mode of the contaning MEM, if any, otherwise VOIDmode. */ machine_mode memmode; }; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef key *compare_type; + static inline hashval_t hash (const cselib_val *); + static inline bool equal (const cselib_val *, const key *); }; /* The hash function for our hash table. The value is always computed with @@ -120,7 +121,7 @@ struct cselib_hasher : typed_noop_remove <cselib_val> hash value from a cselib_val structure. */ inline hashval_t -cselib_hasher::hash (const value_type *v) +cselib_hasher::hash (const cselib_val *v) { return v->hash; } @@ -131,7 +132,7 @@ cselib_hasher::hash (const value_type *v) CONST of an appropriate mode. */ inline bool -cselib_hasher::equal (const value_type *v, const compare_type *x_arg) +cselib_hasher::equal (const cselib_val *v, const key *x_arg) { struct elt_loc_list *l; rtx x = x_arg->x; @@ -507,7 +508,7 @@ preserve_constants_and_equivs (cselib_val **x, void *info ATTRIBUTE_UNUSED) if (invariant_or_equiv_p (v)) { - cselib_hasher::compare_type lookup = { + cselib_hasher::key lookup = { GET_MODE (v->val_rtx), v->val_rtx, VOIDmode }; cselib_val **slot @@ -592,7 +593,7 @@ cselib_find_slot (machine_mode mode, rtx x, hashval_t hash, enum insert_option insert, machine_mode memmode) { cselib_val **slot = NULL; - cselib_hasher::compare_type lookup = { mode, x, memmode }; + cselib_hasher::key lookup = { mode, x, memmode }; if (cselib_preserve_constants) slot = cselib_preserved_hash_table->find_slot_with_hash (&lookup, hash, NO_INSERT); diff --git a/gcc/dse.c b/gcc/dse.c index 2bb20d7..603cdbd 100644 --- a/gcc/dse.c +++ b/gcc/dse.c @@ -667,21 +667,21 @@ clear_alias_set_lookup (alias_set_type alias_set) struct invariant_group_base_hasher : typed_noop_remove <group_info> { - typedef group_info value_type; - typedef group_info compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef group_info *value_type; + typedef group_info *compare_type; + static inline hashval_t hash (const group_info *); + static inline bool equal (const group_info *, const group_info *); }; inline bool -invariant_group_base_hasher::equal (const value_type *gi1, - const compare_type *gi2) +invariant_group_base_hasher::equal (const group_info *gi1, + const group_info *gi2) { return rtx_equal_p (gi1->rtx_base, gi2->rtx_base); } inline hashval_t -invariant_group_base_hasher::hash (const value_type *gi) +invariant_group_base_hasher::hash (const group_info *gi) { int do_not_record; return hash_rtx (gi->rtx_base, Pmode, &do_not_record, NULL, false); diff --git a/gcc/dwarf2cfi.c b/gcc/dwarf2cfi.c index ec2acc9..2469c25 100644 --- a/gcc/dwarf2cfi.c +++ b/gcc/dwarf2cfi.c @@ -182,20 +182,20 @@ typedef dw_trace_info *dw_trace_info_ref; struct trace_info_hasher : typed_noop_remove <dw_trace_info> { - typedef dw_trace_info value_type; - typedef dw_trace_info compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef dw_trace_info *value_type; + typedef dw_trace_info *compare_type; + static inline hashval_t hash (const dw_trace_info *); + static inline bool equal (const dw_trace_info *, const dw_trace_info *); }; inline hashval_t -trace_info_hasher::hash (const value_type *ti) +trace_info_hasher::hash (const dw_trace_info *ti) { return INSN_UID (ti->head); } inline bool -trace_info_hasher::equal (const value_type *a, const compare_type *b) +trace_info_hasher::equal (const dw_trace_info *a, const dw_trace_info *b) { return a->head == b->head; } diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c index 6c8e51f..2c33fd5 100644 --- a/gcc/dwarf2out.c +++ b/gcc/dwarf2out.c @@ -6865,28 +6865,28 @@ struct cu_hash_table_entry struct cu_hash_table_entry_hasher { - typedef cu_hash_table_entry value_type; - typedef die_struct compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); - static inline void remove (value_type *); + typedef cu_hash_table_entry *value_type; + typedef die_struct *compare_type; + static inline hashval_t hash (const cu_hash_table_entry *); + static inline bool equal (const cu_hash_table_entry *, const die_struct *); + static inline void remove (cu_hash_table_entry *); }; inline hashval_t -cu_hash_table_entry_hasher::hash (const value_type *entry) +cu_hash_table_entry_hasher::hash (const cu_hash_table_entry *entry) { return htab_hash_string (entry->cu->die_id.die_symbol); } inline bool -cu_hash_table_entry_hasher::equal (const value_type *entry1, - const compare_type *entry2) +cu_hash_table_entry_hasher::equal (const cu_hash_table_entry *entry1, + const die_struct *entry2) { return !strcmp (entry1->cu->die_id.die_symbol, entry2->die_id.die_symbol); } inline void -cu_hash_table_entry_hasher::remove (value_type *entry) +cu_hash_table_entry_hasher::remove (cu_hash_table_entry *entry) { struct cu_hash_table_entry *next; @@ -7202,21 +7202,21 @@ struct decl_table_entry struct decl_table_entry_hasher : typed_free_remove <decl_table_entry> { - typedef decl_table_entry value_type; - typedef die_struct compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef decl_table_entry *value_type; + typedef die_struct *compare_type; + static inline hashval_t hash (const decl_table_entry *); + static inline bool equal (const decl_table_entry *, const die_struct *); }; inline hashval_t -decl_table_entry_hasher::hash (const value_type *entry) +decl_table_entry_hasher::hash (const decl_table_entry *entry) { return htab_hash_pointer (entry->orig); } inline bool -decl_table_entry_hasher::equal (const value_type *entry1, - const compare_type *entry2) +decl_table_entry_hasher::equal (const decl_table_entry *entry1, + const die_struct *entry2) { return entry1->orig == entry2; } @@ -7744,14 +7744,14 @@ struct external_ref struct external_ref_hasher : typed_free_remove <external_ref> { - typedef external_ref value_type; - typedef external_ref compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef external_ref *value_type; + typedef external_ref *compare_type; + static inline hashval_t hash (const external_ref *); + static inline bool equal (const external_ref *, const external_ref *); }; inline hashval_t -external_ref_hasher::hash (const value_type *r) +external_ref_hasher::hash (const external_ref *r) { dw_die_ref die = r->type; hashval_t h = 0; @@ -7772,7 +7772,7 @@ external_ref_hasher::hash (const value_type *r) } inline bool -external_ref_hasher::equal (const value_type *r1, const compare_type *r2) +external_ref_hasher::equal (const external_ref *r1, const external_ref *r2) { return r1->type == r2->type; } @@ -22224,21 +22224,21 @@ dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED, struct macinfo_entry_hasher : typed_noop_remove <macinfo_entry> { - typedef macinfo_entry value_type; - typedef macinfo_entry compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef macinfo_entry *value_type; + typedef macinfo_entry *compare_type; + static inline hashval_t hash (const macinfo_entry *); + static inline bool equal (const macinfo_entry *, const macinfo_entry *); }; inline hashval_t -macinfo_entry_hasher::hash (const value_type *entry) +macinfo_entry_hasher::hash (const macinfo_entry *entry) { return htab_hash_string (entry->info); } inline bool -macinfo_entry_hasher::equal (const value_type *entry1, - const compare_type *entry2) +macinfo_entry_hasher::equal (const macinfo_entry *entry1, + const macinfo_entry *entry2) { return !strcmp (entry1->info, entry2->info); } @@ -23302,14 +23302,14 @@ file_table_relative_p (dwarf_file_data **slot, bool *p) struct comdat_type_hasher : typed_noop_remove <comdat_type_node> { - typedef comdat_type_node value_type; - typedef comdat_type_node compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef comdat_type_node *value_type; + typedef comdat_type_node *compare_type; + static inline hashval_t hash (const comdat_type_node *); + static inline bool equal (const comdat_type_node *, const comdat_type_node *); }; inline hashval_t -comdat_type_hasher::hash (const value_type *type_node) +comdat_type_hasher::hash (const comdat_type_node *type_node) { hashval_t h; memcpy (&h, type_node->signature, sizeof (h)); @@ -23317,8 +23317,8 @@ comdat_type_hasher::hash (const value_type *type_node) } inline bool -comdat_type_hasher::equal (const value_type *type_node_1, - const compare_type *type_node_2) +comdat_type_hasher::equal (const comdat_type_node *type_node_1, + const comdat_type_node *type_node_2) { return (! memcmp (type_node_1->signature, type_node_2->signature, DWARF_TYPE_SIGNATURE_SIZE)); @@ -24405,16 +24405,17 @@ compare_locs (dw_loc_descr_ref x, dw_loc_descr_ref y) struct loc_list_hasher : typed_noop_remove <dw_loc_list_struct> { - typedef dw_loc_list_struct value_type; - typedef dw_loc_list_struct compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef dw_loc_list_struct *value_type; + typedef dw_loc_list_struct *compare_type; + static inline hashval_t hash (const dw_loc_list_struct *); + static inline bool equal (const dw_loc_list_struct *, + const dw_loc_list_struct *); }; /* Return precomputed hash of location list X. */ inline hashval_t -loc_list_hasher::hash (const value_type *x) +loc_list_hasher::hash (const dw_loc_list_struct *x) { return x->hash; } @@ -24422,7 +24423,8 @@ loc_list_hasher::hash (const value_type *x) /* Return true if location lists A and B are the same. */ inline bool -loc_list_hasher::equal (const value_type *a, const compare_type *b) +loc_list_hasher::equal (const dw_loc_list_struct *a, + const dw_loc_list_struct *b) { if (a == b) return 1; diff --git a/gcc/except.c b/gcc/except.c index 833ec21..f85e55a 100644 --- a/gcc/except.c +++ b/gcc/except.c @@ -227,20 +227,21 @@ struct action_record struct action_record_hasher : typed_free_remove <action_record> { - typedef action_record value_type; - typedef action_record compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef action_record *value_type; + typedef action_record *compare_type; + static inline hashval_t hash (const action_record *); + static inline bool equal (const action_record *, const action_record *); }; inline hashval_t -action_record_hasher::hash (const value_type *entry) +action_record_hasher::hash (const action_record *entry) { return entry->next * 1009 + entry->filter; } inline bool -action_record_hasher::equal (const value_type *entry, const compare_type *data) +action_record_hasher::equal (const action_record *entry, + const action_record *data) { return entry->filter == data->filter && entry->next == data->next; } @@ -742,23 +743,23 @@ struct ttypes_filter { struct ttypes_filter_hasher : typed_free_remove <ttypes_filter> { - typedef ttypes_filter value_type; - typedef tree_node compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef ttypes_filter *value_type; + typedef tree_node *compare_type; + static inline hashval_t hash (const ttypes_filter *); + static inline bool equal (const ttypes_filter *, const tree_node *); }; /* Compare ENTRY (a ttypes_filter entry in the hash table) with DATA (a tree) for a @TTypes type node we are thinking about adding. */ inline bool -ttypes_filter_hasher::equal (const value_type *entry, const compare_type *data) +ttypes_filter_hasher::equal (const ttypes_filter *entry, const tree_node *data) { return entry->t == data; } inline hashval_t -ttypes_filter_hasher::hash (const value_type *entry) +ttypes_filter_hasher::hash (const ttypes_filter *entry) { return TREE_HASH (entry->t); } @@ -770,10 +771,10 @@ typedef hash_table<ttypes_filter_hasher> ttypes_hash_type; struct ehspec_hasher : typed_free_remove <ttypes_filter> { - typedef ttypes_filter value_type; - typedef ttypes_filter compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef ttypes_filter *value_type; + typedef ttypes_filter *compare_type; + static inline hashval_t hash (const ttypes_filter *); + static inline bool equal (const ttypes_filter *, const ttypes_filter *); }; /* Compare ENTRY with DATA (both struct ttypes_filter) for a @TTypes @@ -782,7 +783,7 @@ struct ehspec_hasher : typed_free_remove <ttypes_filter> should put these in some canonical order. */ inline bool -ehspec_hasher::equal (const value_type *entry, const compare_type *data) +ehspec_hasher::equal (const ttypes_filter *entry, const ttypes_filter *data) { return type_list_equal (entry->t, data->t); } @@ -790,7 +791,7 @@ ehspec_hasher::equal (const value_type *entry, const compare_type *data) /* Hash function for exception specification lists. */ inline hashval_t -ehspec_hasher::hash (const value_type *entry) +ehspec_hasher::hash (const ttypes_filter *entry) { hashval_t h = 0; tree list; diff --git a/gcc/gcse.c b/gcc/gcse.c index 37aac6a..4be3f36 100644 --- a/gcc/gcse.c +++ b/gcc/gcse.c @@ -388,15 +388,15 @@ static struct ls_expr * pre_ldst_mems = NULL; struct pre_ldst_expr_hasher : typed_noop_remove <ls_expr> { - typedef ls_expr value_type; + typedef ls_expr *value_type; typedef value_type compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + static inline hashval_t hash (const ls_expr *); + static inline bool equal (const ls_expr *, const ls_expr *); }; /* Hashtable helpers. */ inline hashval_t -pre_ldst_expr_hasher::hash (const value_type *x) +pre_ldst_expr_hasher::hash (const ls_expr *x) { int do_not_record_p = 0; return @@ -406,8 +406,8 @@ pre_ldst_expr_hasher::hash (const value_type *x) static int expr_equiv_p (const_rtx, const_rtx); inline bool -pre_ldst_expr_hasher::equal (const value_type *ptr1, - const compare_type *ptr2) +pre_ldst_expr_hasher::equal (const ls_expr *ptr1, + const ls_expr *ptr2) { return expr_equiv_p (ptr1->pattern, ptr2->pattern); } diff --git a/gcc/genmatch.c b/gcc/genmatch.c index 560a371..fbd12a5 100644 --- a/gcc/genmatch.c +++ b/gcc/genmatch.c @@ -190,21 +190,21 @@ struct id_base : typed_noop_remove<id_base> const char *id; /* hash_table support. */ - typedef id_base value_type; - typedef id_base compare_type; - static inline hashval_t hash (const value_type *); - static inline int equal (const value_type *, const compare_type *); + typedef id_base *value_type; + typedef id_base *compare_type; + static inline hashval_t hash (const id_base *); + static inline int equal (const id_base *, const id_base *); }; inline hashval_t -id_base::hash (const value_type *op) +id_base::hash (const id_base *op) { return op->hashval; } inline int -id_base::equal (const value_type *op1, - const compare_type *op2) +id_base::equal (const id_base *op1, + const id_base *op2) { return (op1->hashval == op2->hashval && strcmp (op1->id, op2->id) == 0); diff --git a/gcc/ggc-common.c b/gcc/ggc-common.c index 03fbe7d..eff326a 100644 --- a/gcc/ggc-common.c +++ b/gcc/ggc-common.c @@ -242,20 +242,20 @@ struct ptr_data struct saving_hasher : typed_free_remove <ptr_data> { - typedef ptr_data value_type; - typedef void compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef ptr_data *value_type; + typedef void *compare_type; + static inline hashval_t hash (const ptr_data *); + static inline bool equal (const ptr_data *, const void *); }; inline hashval_t -saving_hasher::hash (const value_type *p) +saving_hasher::hash (const ptr_data *p) { return POINTER_HASH (p->obj); } inline bool -saving_hasher::equal (const value_type *p1, const compare_type *p2) +saving_hasher::equal (const ptr_data *p1, const void *p2) { return p1->obj == p2; } @@ -847,20 +847,22 @@ struct ggc_loc_descriptor struct ggc_loc_desc_hasher : typed_noop_remove <ggc_loc_descriptor> { - typedef ggc_loc_descriptor value_type; - typedef ggc_loc_descriptor compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef ggc_loc_descriptor *value_type; + typedef ggc_loc_descriptor *compare_type; + static inline hashval_t hash (const ggc_loc_descriptor *); + static inline bool equal (const ggc_loc_descriptor *, + const ggc_loc_descriptor *); }; inline hashval_t -ggc_loc_desc_hasher::hash (const value_type *d) +ggc_loc_desc_hasher::hash (const ggc_loc_descriptor *d) { return htab_hash_pointer (d->function) | d->line; } inline bool -ggc_loc_desc_hasher::equal (const value_type *d, const compare_type *d2) +ggc_loc_desc_hasher::equal (const ggc_loc_descriptor *d, + const ggc_loc_descriptor *d2) { return (d->file == d2->file && d->line == d2->line && d->function == d2->function); @@ -880,20 +882,20 @@ struct ggc_ptr_hash_entry struct ptr_hash_hasher : typed_noop_remove <ggc_ptr_hash_entry> { - typedef ggc_ptr_hash_entry value_type; - typedef void compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef ggc_ptr_hash_entry *value_type; + typedef void *compare_type; + static inline hashval_t hash (const ggc_ptr_hash_entry *); + static inline bool equal (const ggc_ptr_hash_entry *, const void *); }; inline hashval_t -ptr_hash_hasher::hash (const value_type *d) +ptr_hash_hasher::hash (const ggc_ptr_hash_entry *d) { return htab_hash_pointer (d->ptr); } inline bool -ptr_hash_hasher::equal (const value_type *p, const compare_type *p2) +ptr_hash_hasher::equal (const ggc_ptr_hash_entry *p, const void *p2) { return (p->ptr == p2); } diff --git a/gcc/gimple-ssa-strength-reduction.c b/gcc/gimple-ssa-strength-reduction.c index 5b84bbe..afd3215 100644 --- a/gcc/gimple-ssa-strength-reduction.c +++ b/gcc/gimple-ssa-strength-reduction.c @@ -438,21 +438,21 @@ lookup_cand (cand_idx idx) struct cand_chain_hasher : typed_noop_remove <cand_chain> { - typedef cand_chain value_type; - typedef cand_chain compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef cand_chain *value_type; + typedef cand_chain *compare_type; + static inline hashval_t hash (const cand_chain *); + static inline bool equal (const cand_chain *, const cand_chain *); }; inline hashval_t -cand_chain_hasher::hash (const value_type *p) +cand_chain_hasher::hash (const cand_chain *p) { tree base_expr = p->base_expr; return iterative_hash_expr (base_expr, 0); } inline bool -cand_chain_hasher::equal (const value_type *chain1, const compare_type *chain2) +cand_chain_hasher::equal (const cand_chain *chain1, const cand_chain *chain2) { return operand_equal_p (chain1->base_expr, chain2->base_expr, 0); } diff --git a/gcc/gimplify.c b/gcc/gimplify.c index ff0a225..a52455d 100644 --- a/gcc/gimplify.c +++ b/gcc/gimplify.c @@ -136,10 +136,10 @@ enum omp_region_type struct gimplify_hasher : typed_free_remove <elt_t> { - typedef elt_t value_type; - typedef elt_t compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef elt_t *value_type; + typedef elt_t *compare_type; + static inline hashval_t hash (const elt_t *); + static inline bool equal (const elt_t *, const elt_t *); }; struct gimplify_ctx @@ -9384,14 +9384,14 @@ gimplify_assign (tree dst, tree src, gimple_seq *seq_p) } inline hashval_t -gimplify_hasher::hash (const value_type *p) +gimplify_hasher::hash (const elt_t *p) { tree t = p->val; return iterative_hash_expr (t, 0); } inline bool -gimplify_hasher::equal (const value_type *p1, const compare_type *p2) +gimplify_hasher::equal (const elt_t *p1, const elt_t *p2) { tree t1 = p1->val; tree t2 = p2->val; diff --git a/gcc/haifa-sched.c b/gcc/haifa-sched.c index ad2450b..96c038f 100644 --- a/gcc/haifa-sched.c +++ b/gcc/haifa-sched.c @@ -621,16 +621,16 @@ struct delay_pair struct delay_i1_hasher : typed_noop_remove <delay_pair> { - typedef delay_pair value_type; - typedef void compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef delay_pair *value_type; + typedef void *compare_type; + static inline hashval_t hash (const delay_pair *); + static inline bool equal (const delay_pair *, const void *); }; /* Returns a hash value for X, based on hashing just I1. */ inline hashval_t -delay_i1_hasher::hash (const value_type *x) +delay_i1_hasher::hash (const delay_pair *x) { return htab_hash_pointer (x->i1); } @@ -638,23 +638,23 @@ delay_i1_hasher::hash (const value_type *x) /* Return true if I1 of pair X is the same as that of pair Y. */ inline bool -delay_i1_hasher::equal (const value_type *x, const compare_type *y) +delay_i1_hasher::equal (const delay_pair *x, const void *y) { return x->i1 == y; } struct delay_i2_hasher : typed_free_remove <delay_pair> { - typedef delay_pair value_type; - typedef void compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef delay_pair *value_type; + typedef void *compare_type; + static inline hashval_t hash (const delay_pair *); + static inline bool equal (const delay_pair *, const void *); }; /* Returns a hash value for X, based on hashing just I2. */ inline hashval_t -delay_i2_hasher::hash (const value_type *x) +delay_i2_hasher::hash (const delay_pair *x) { return htab_hash_pointer (x->i2); } @@ -662,7 +662,7 @@ delay_i2_hasher::hash (const value_type *x) /* Return true if I2 of pair X is the same as that of pair Y. */ inline bool -delay_i2_hasher::equal (const value_type *x, const compare_type *y) +delay_i2_hasher::equal (const delay_pair *x, const void *y) { return x->i2 == y; } diff --git a/gcc/hard-reg-set.h b/gcc/hard-reg-set.h index d1a6e51..89971d7 100644 --- a/gcc/hard-reg-set.h +++ b/gcc/hard-reg-set.h @@ -615,7 +615,17 @@ hard_reg_set_iter_next (hard_reg_set_iterator *iter, unsigned *regno) extern char global_regs[FIRST_PSEUDO_REGISTER]; -struct simplifiable_subregs_hasher; +struct simplifiable_subreg; +struct subreg_shape; + +struct simplifiable_subregs_hasher : typed_noop_remove <simplifiable_subreg> +{ + typedef simplifiable_subreg *value_type; + typedef const subreg_shape *compare_type; + + static inline hashval_t hash (const simplifiable_subreg *); + static inline bool equal (const simplifiable_subreg *, const subreg_shape *); +}; struct target_hard_regs { void finalize (); diff --git a/gcc/hash-map.h b/gcc/hash-map.h index e1dea91..4cca702 100644 --- a/gcc/hash-map.h +++ b/gcc/hash-map.h @@ -114,7 +114,6 @@ class GTY((user)) hash_map typedef hash_entry value_type; typedef Key compare_type; - typedef int store_values_directly; static hashval_t hash (const hash_entry &e) { diff --git a/gcc/hash-set.h b/gcc/hash-set.h index c1e8872..9065451 100644 --- a/gcc/hash-set.h +++ b/gcc/hash-set.h @@ -112,7 +112,6 @@ class hash_set typedef hash_entry value_type; typedef Key compare_type; - typedef int store_values_directly; static hashval_t hash (const hash_entry &e) { diff --git a/gcc/hash-table.h b/gcc/hash-table.h index 447eaff..f6375d1 100644 --- a/gcc/hash-table.h +++ b/gcc/hash-table.h @@ -278,7 +278,6 @@ struct pointer_hash : typed_noop_remove <Type> { typedef Type *value_type; typedef Type *compare_type; - typedef int store_values_directly; static inline hashval_t hash (const value_type &); @@ -310,7 +309,6 @@ struct ggc_hasher { typedef T value_type; typedef T compare_type; - typedef int store_values_directly; static void remove (T) {} @@ -342,7 +340,6 @@ struct ggc_cache_hasher { typedef T value_type; typedef T compare_type; - typedef int store_values_directly; static void remove (T &) {} @@ -438,26 +435,6 @@ hash_table_mod2 (hashval_t hash, unsigned int index) return 1 + mul_mod (hash, p->prime - 2, p->inv_m2, p->shift); } -/* The below is some template meta programming to decide if we should use the - hash table partial specialization that directly stores value_type instead of - pointers to value_type. If the Descriptor type defines the type - Descriptor::store_values_directly then values are stored directly otherwise - pointers to them are stored. */ -template<typename T> struct notype { typedef void type; }; - -template<typename T, typename = void> -struct storage_tester -{ - static const bool value = false; -}; - -template<typename T> -struct storage_tester<T, typename notype<typename - T::store_values_directly>::type> -{ - static const bool value = true; -}; - template<typename Traits> struct has_is_deleted { @@ -576,9 +553,7 @@ struct mark_empty_helper<Type *, Traits, false> /* User-facing hash table type. - The table stores elements of type Descriptor::value_type, or pointers to - objects of type value_type if the descriptor does not define the type - store_values_directly. + The table stores elements of type Descriptor::value_type. It hashes values with the hash member function. The table currently works with relatively weak hash functions. @@ -601,518 +576,9 @@ struct mark_empty_helper<Type *, Traits, false> */ template <typename Descriptor, - template<typename Type> class Allocator= xcallocator, - bool Storage = storage_tester<Descriptor>::value> + template<typename Type> class Allocator = xcallocator> class hash_table { -}; - -template <typename Descriptor, - template<typename Type> class Allocator> -class hash_table<Descriptor, Allocator, false> -{ - typedef typename Descriptor::value_type value_type; - typedef typename Descriptor::compare_type compare_type; - -public: - hash_table (size_t CXX_MEM_STAT_INFO); - ~hash_table (); - - /* Current size (in entries) of the hash table. */ - size_t size () const { return m_size; } - - /* Return the current number of elements in this hash table. */ - size_t elements () const { return m_n_elements - m_n_deleted; } - - /* Return the current number of elements in this hash table. */ - size_t elements_with_deleted () const { return m_n_elements; } - - /* This function clears all entries in the given hash table. */ - void empty (); - - /* This function clears a specified SLOT in a hash table. It is - useful when you've already done the lookup and don't want to do it - again. */ - - void clear_slot (value_type **); - - /* This function searches for a hash table entry equal to the given - COMPARABLE element starting with the given HASH value. It cannot - be used to insert or delete an element. */ - value_type *find_with_hash (const compare_type *, hashval_t); - -/* Like find_slot_with_hash, but compute the hash value from the element. */ - value_type *find (const value_type *value) - { - return find_with_hash (value, Descriptor::hash (value)); - } - - value_type **find_slot (const value_type *value, insert_option insert) - { - return find_slot_with_hash (value, Descriptor::hash (value), insert); - } - - /* This function searches for a hash table slot containing an entry - equal to the given COMPARABLE element and starting with the given - HASH. To delete an entry, call this with insert=NO_INSERT, then - call clear_slot on the slot returned (possibly after doing some - checks). To insert an entry, call this with insert=INSERT, then - write the value you want into the returned slot. When inserting an - entry, NULL may be returned if memory allocation fails. */ - value_type **find_slot_with_hash (const compare_type *comparable, - hashval_t hash, enum insert_option insert); - - /* This function deletes an element with the given COMPARABLE value - from hash table starting with the given HASH. If there is no - matching element in the hash table, this function does nothing. */ - void remove_elt_with_hash (const compare_type *, hashval_t); - -/* Like remove_elt_with_hash, but compute the hash value from the element. */ - void remove_elt (const value_type *value) - { - remove_elt_with_hash (value, Descriptor::hash (value)); - } - - /* This function scans over the entire hash table calling CALLBACK for - each live entry. If CALLBACK returns false, the iteration stops. - ARGUMENT is passed as CALLBACK's second argument. */ - template <typename Argument, - int (*Callback) (value_type **slot, Argument argument)> - void traverse_noresize (Argument argument); - - /* Like traverse_noresize, but does resize the table when it is too empty - to improve effectivity of subsequent calls. */ - template <typename Argument, - int (*Callback) (value_type **slot, Argument argument)> - void traverse (Argument argument); - - class iterator - { - public: - iterator () : m_slot (NULL), m_limit (NULL) {} - - iterator (value_type **slot, value_type **limit) : - m_slot (slot), m_limit (limit) {} - - inline value_type *operator * () { return *m_slot; } - void slide (); - inline iterator &operator ++ (); - bool operator != (const iterator &other) const - { - return m_slot != other.m_slot || m_limit != other.m_limit; - } - - private: - value_type **m_slot; - value_type **m_limit; - }; - - iterator begin () const - { - iterator iter (m_entries, m_entries + m_size); - iter.slide (); - return iter; - } - - iterator end () const { return iterator (); } - - double collisions () const - { - return m_searches ? static_cast <double> (m_collisions) / m_searches : 0; - } - -private: - - value_type **find_empty_slot_for_expand (hashval_t); - void expand (); - - /* Table itself. */ - typename Descriptor::value_type **m_entries; - - size_t m_size; - - /* Current number of elements including also deleted elements. */ - size_t m_n_elements; - - /* Current number of deleted elements in the table. */ - size_t m_n_deleted; - - /* The following member is used for debugging. Its value is number - of all calls of `htab_find_slot' for the hash table. */ - unsigned int m_searches; - - /* The following member is used for debugging. Its value is number - of collisions fixed for time of work with the hash table. */ - unsigned int m_collisions; - - /* Current size (in entries) of the hash table, as an index into the - table of primes. */ - unsigned int m_size_prime_index; -}; - -template<typename Descriptor, template<typename Type> class Allocator> -hash_table<Descriptor, Allocator, false>::hash_table (size_t size - MEM_STAT_DECL) : - m_n_elements (0), m_n_deleted (0), m_searches (0), m_collisions (0) -{ - 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); - gcc_assert (m_entries != NULL); - m_size = size; - m_size_prime_index = size_prime_index; -} - -template<typename Descriptor, template<typename Type> class Allocator> -hash_table<Descriptor, Allocator, false>::~hash_table () -{ - for (size_t i = m_size - 1; i < m_size; i--) - if (m_entries[i] != HTAB_EMPTY_ENTRY && m_entries[i] != HTAB_DELETED_ENTRY) - Descriptor::remove (m_entries[i]); - - Allocator <value_type *> ::data_free (m_entries); -} - -/* Similar to find_slot, but without several unwanted side effects: - - Does not call equal when it finds an existing entry. - - Does not change the count of elements/searches/collisions in the - hash table. - This function also assumes there are no deleted entries in the table. - HASH is the hash value for the element to be inserted. */ - -template<typename Descriptor, template<typename Type> class Allocator> -typename hash_table<Descriptor, Allocator, false>::value_type ** -hash_table<Descriptor, Allocator, false> -::find_empty_slot_for_expand (hashval_t hash) -{ - hashval_t index = hash_table_mod1 (hash, m_size_prime_index); - size_t size = m_size; - value_type **slot = m_entries + index; - hashval_t hash2; - - if (*slot == HTAB_EMPTY_ENTRY) - return slot; - gcc_checking_assert (*slot != HTAB_DELETED_ENTRY); - - hash2 = hash_table_mod2 (hash, m_size_prime_index); - for (;;) - { - index += hash2; - if (index >= size) - index -= size; - - slot = m_entries + index; - if (*slot == HTAB_EMPTY_ENTRY) - return slot; - gcc_checking_assert (*slot != HTAB_DELETED_ENTRY); - } -} - -/* The following function changes size of memory allocated for the - entries and repeatedly inserts the table elements. The occupancy - of the table after the call will be about 50%. Naturally the hash - table must already exist. Remember also that the place of the - table entries is changed. If memory allocation fails, this function - will abort. */ - -template<typename Descriptor, template<typename Type> class Allocator> -void -hash_table<Descriptor, Allocator, false>::expand () -{ - value_type **oentries = m_entries; - unsigned int oindex = m_size_prime_index; - size_t osize = size (); - value_type **olimit = oentries + osize; - size_t elts = elements (); - - /* Resize only when table after removal of unused elements is either - too full or too empty. */ - unsigned int nindex; - size_t nsize; - if (elts * 2 > osize || (elts * 8 < osize && osize > 32)) - { - nindex = hash_table_higher_prime_index (elts * 2); - nsize = prime_tab[nindex].prime; - } - else - { - nindex = oindex; - nsize = osize; - } - - value_type **nentries = Allocator <value_type *> ::data_alloc (nsize); - gcc_assert (nentries != NULL); - m_entries = nentries; - m_size = nsize; - m_size_prime_index = nindex; - m_n_elements -= m_n_deleted; - m_n_deleted = 0; - - value_type **p = oentries; - do - { - value_type *x = *p; - - if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY) - { - value_type **q = find_empty_slot_for_expand (Descriptor::hash (x)); - - *q = x; - } - - p++; - } - while (p < olimit); - - Allocator <value_type *> ::data_free (oentries); -} - -template<typename Descriptor, template<typename Type> class Allocator> -void -hash_table<Descriptor, Allocator, false>::empty () -{ - size_t size = m_size; - value_type **entries = m_entries; - int i; - - for (i = size - 1; i >= 0; i--) - if (entries[i] != HTAB_EMPTY_ENTRY && entries[i] != HTAB_DELETED_ENTRY) - Descriptor::remove (entries[i]); - - /* Instead of clearing megabyte, downsize the table. */ - if (size > 1024*1024 / sizeof (PTR)) - { - 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); - m_size = nsize; - m_size_prime_index = nindex; - } - else - memset (entries, 0, size * sizeof (value_type *)); - m_n_deleted = 0; - m_n_elements = 0; -} - -/* This function clears a specified SLOT in a hash table. It is - useful when you've already done the lookup and don't want to do it - again. */ - -template<typename Descriptor, template<typename Type> class Allocator> -void -hash_table<Descriptor, Allocator, false>::clear_slot (value_type **slot) -{ - gcc_checking_assert (!(slot < m_entries || slot >= m_entries + size () - || *slot == HTAB_EMPTY_ENTRY - || *slot == HTAB_DELETED_ENTRY)); - - Descriptor::remove (*slot); - - *slot = static_cast <value_type *> (HTAB_DELETED_ENTRY); - m_n_deleted++; -} - -/* This function searches for a hash table entry equal to the given - COMPARABLE element starting with the given HASH value. It cannot - be used to insert or delete an element. */ - -template<typename Descriptor, template<typename Type> class Allocator> -typename hash_table<Descriptor, Allocator, false>::value_type * -hash_table<Descriptor, Allocator, false> -::find_with_hash (const compare_type *comparable, hashval_t hash) -{ - m_searches++; - size_t size = m_size; - hashval_t index = hash_table_mod1 (hash, m_size_prime_index); - - value_type *entry = m_entries[index]; - if (entry == HTAB_EMPTY_ENTRY - || (entry != HTAB_DELETED_ENTRY && Descriptor::equal (entry, comparable))) - return entry; - - hashval_t hash2 = hash_table_mod2 (hash, m_size_prime_index); - for (;;) - { - m_collisions++; - index += hash2; - if (index >= size) - index -= size; - - entry = m_entries[index]; - if (entry == HTAB_EMPTY_ENTRY - || (entry != HTAB_DELETED_ENTRY - && Descriptor::equal (entry, comparable))) - return entry; - } -} - -/* This function searches for a hash table slot containing an entry - equal to the given COMPARABLE element and starting with the given - HASH. To delete an entry, call this with insert=NO_INSERT, then - call clear_slot on the slot returned (possibly after doing some - checks). To insert an entry, call this with insert=INSERT, then - write the value you want into the returned slot. When inserting an - entry, NULL may be returned if memory allocation fails. */ - -template<typename Descriptor, template<typename Type> class Allocator> -typename hash_table<Descriptor, Allocator, false>::value_type ** -hash_table<Descriptor, Allocator, false> -::find_slot_with_hash (const compare_type *comparable, hashval_t hash, - enum insert_option insert) -{ - if (insert == INSERT && m_size * 3 <= m_n_elements * 4) - expand (); - - m_searches++; - - value_type **first_deleted_slot = NULL; - hashval_t index = hash_table_mod1 (hash, m_size_prime_index); - hashval_t hash2 = hash_table_mod2 (hash, m_size_prime_index); - value_type *entry = m_entries[index]; - size_t size = m_size; - if (entry == HTAB_EMPTY_ENTRY) - goto empty_entry; - else if (entry == HTAB_DELETED_ENTRY) - first_deleted_slot = &m_entries[index]; - else if (Descriptor::equal (entry, comparable)) - return &m_entries[index]; - - for (;;) - { - m_collisions++; - index += hash2; - if (index >= size) - index -= size; - - entry = m_entries[index]; - if (entry == HTAB_EMPTY_ENTRY) - goto empty_entry; - else if (entry == HTAB_DELETED_ENTRY) - { - if (!first_deleted_slot) - first_deleted_slot = &m_entries[index]; - } - else if (Descriptor::equal (entry, comparable)) - return &m_entries[index]; - } - - empty_entry: - if (insert == NO_INSERT) - return NULL; - - if (first_deleted_slot) - { - m_n_deleted--; - *first_deleted_slot = static_cast <value_type *> (HTAB_EMPTY_ENTRY); - return first_deleted_slot; - } - - m_n_elements++; - return &m_entries[index]; -} - -/* This function deletes an element with the given COMPARABLE value - from hash table starting with the given HASH. If there is no - matching element in the hash table, this function does nothing. */ - -template<typename Descriptor, template<typename Type> class Allocator> -void -hash_table<Descriptor, Allocator, false> -::remove_elt_with_hash (const compare_type *comparable, hashval_t hash) -{ - value_type **slot = find_slot_with_hash (comparable, hash, NO_INSERT); - if (*slot == HTAB_EMPTY_ENTRY) - return; - - Descriptor::remove (*slot); - - *slot = static_cast <value_type *> (HTAB_DELETED_ENTRY); - m_n_deleted++; -} - -/* This function scans over the entire hash table calling CALLBACK for - each live entry. If CALLBACK returns false, the iteration stops. - ARGUMENT is passed as CALLBACK's second argument. */ - -template<typename Descriptor, template<typename Type> class Allocator> -template<typename Argument, - int (*Callback) (typename hash_table<Descriptor, Allocator, - false>::value_type **slot, - Argument argument)> -void -hash_table<Descriptor, Allocator, false>::traverse_noresize (Argument argument) -{ - value_type **slot = m_entries; - value_type **limit = slot + size (); - - do - { - value_type *x = *slot; - - if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY) - if (! Callback (slot, argument)) - break; - } - while (++slot < limit); -} - -/* Like traverse_noresize, but does resize the table when it is too empty - to improve effectivity of subsequent calls. */ - -template <typename Descriptor, - template <typename Type> class Allocator> -template <typename Argument, - int (*Callback) (typename hash_table<Descriptor, Allocator, - false>::value_type **slot, - Argument argument)> -void -hash_table<Descriptor, Allocator, false>::traverse (Argument argument) -{ - size_t size = m_size; - if (elements () * 8 < size && size > 32) - expand (); - - traverse_noresize <Argument, Callback> (argument); -} - -/* Slide down the iterator slots until an active entry is found. */ - -template<typename Descriptor, template<typename Type> class Allocator> -void -hash_table<Descriptor, Allocator, false>::iterator::slide () -{ - for ( ; m_slot < m_limit; ++m_slot ) - { - value_type *x = *m_slot; - if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY) - return; - } - m_slot = NULL; - m_limit = NULL; -} - -/* Bump the iterator. */ - -template<typename Descriptor, template<typename Type> class Allocator> -inline typename hash_table<Descriptor, Allocator, false>::iterator & -hash_table<Descriptor, Allocator, false>::iterator::operator ++ () -{ - ++m_slot; - slide (); - return *this; -} - -/* A partial specialization used when values should be stored directly. */ - -template <typename Descriptor, - template<typename Type> class Allocator> -class hash_table<Descriptor, Allocator, true> -{ typedef typename Descriptor::value_type value_type; typedef typename Descriptor::compare_type compare_type; @@ -1296,7 +762,7 @@ private: }; template<typename Descriptor, template<typename Type> class Allocator> -hash_table<Descriptor, Allocator, true>::hash_table (size_t size, bool ggc +hash_table<Descriptor, Allocator>::hash_table (size_t size, bool ggc MEM_STAT_DECL) : m_n_elements (0), m_n_deleted (0), m_searches (0), m_collisions (0), m_ggc (ggc) @@ -1312,7 +778,7 @@ hash_table<Descriptor, Allocator, true>::hash_table (size_t size, bool ggc } template<typename Descriptor, template<typename Type> class Allocator> -hash_table<Descriptor, Allocator, true>::~hash_table () +hash_table<Descriptor, Allocator>::~hash_table () { for (size_t i = m_size - 1; i < m_size; i--) if (!is_empty (m_entries[i]) && !is_deleted (m_entries[i])) @@ -1327,9 +793,8 @@ hash_table<Descriptor, Allocator, true>::~hash_table () /* This function returns an array of empty hash table elements. */ template<typename Descriptor, template<typename Type> class Allocator> -inline typename hash_table<Descriptor, Allocator, true>::value_type * -hash_table<Descriptor, Allocator, true>::alloc_entries - (size_t n MEM_STAT_DECL) const +inline typename hash_table<Descriptor, Allocator>::value_type * +hash_table<Descriptor, Allocator>::alloc_entries (size_t n MEM_STAT_DECL) const { value_type *nentries; @@ -1353,9 +818,8 @@ hash_table<Descriptor, Allocator, true>::alloc_entries HASH is the hash value for the element to be inserted. */ template<typename Descriptor, template<typename Type> class Allocator> -typename hash_table<Descriptor, Allocator, true>::value_type * -hash_table<Descriptor, Allocator, true> -::find_empty_slot_for_expand (hashval_t hash) +typename hash_table<Descriptor, Allocator>::value_type * +hash_table<Descriptor, Allocator>::find_empty_slot_for_expand (hashval_t hash) { hashval_t index = hash_table_mod1 (hash, m_size_prime_index); size_t size = m_size; @@ -1393,7 +857,7 @@ hash_table<Descriptor, Allocator, true> template<typename Descriptor, template<typename Type> class Allocator> void -hash_table<Descriptor, Allocator, true>::expand () +hash_table<Descriptor, Allocator>::expand () { value_type *oentries = m_entries; unsigned int oindex = m_size_prime_index; @@ -1447,7 +911,7 @@ hash_table<Descriptor, Allocator, true>::expand () template<typename Descriptor, template<typename Type> class Allocator> void -hash_table<Descriptor, Allocator, true>::empty () +hash_table<Descriptor, Allocator>::empty () { size_t size = m_size; value_type *entries = m_entries; @@ -1484,7 +948,7 @@ hash_table<Descriptor, Allocator, true>::empty () template<typename Descriptor, template<typename Type> class Allocator> void -hash_table<Descriptor, Allocator, true>::clear_slot (value_type *slot) +hash_table<Descriptor, Allocator>::clear_slot (value_type *slot) { gcc_checking_assert (!(slot < m_entries || slot >= m_entries + size () || is_empty (*slot) || is_deleted (*slot))); @@ -1500,8 +964,8 @@ hash_table<Descriptor, Allocator, true>::clear_slot (value_type *slot) be used to insert or delete an element. */ template<typename Descriptor, template<typename Type> class Allocator> -typename hash_table<Descriptor, Allocator, true>::value_type & -hash_table<Descriptor, Allocator, true> +typename hash_table<Descriptor, Allocator>::value_type & +hash_table<Descriptor, Allocator> ::find_with_hash (const compare_type &comparable, hashval_t hash) { m_searches++; @@ -1537,8 +1001,8 @@ hash_table<Descriptor, Allocator, true> entry, NULL may be returned if memory allocation fails. */ template<typename Descriptor, template<typename Type> class Allocator> -typename hash_table<Descriptor, Allocator, true>::value_type * -hash_table<Descriptor, Allocator, true> +typename hash_table<Descriptor, Allocator>::value_type * +hash_table<Descriptor, Allocator> ::find_slot_with_hash (const compare_type &comparable, hashval_t hash, enum insert_option insert) { @@ -1599,7 +1063,7 @@ hash_table<Descriptor, Allocator, true> template<typename Descriptor, template<typename Type> class Allocator> void -hash_table<Descriptor, Allocator, true> +hash_table<Descriptor, Allocator> ::remove_elt_with_hash (const compare_type &comparable, hashval_t hash) { value_type *slot = find_slot_with_hash (comparable, hash, NO_INSERT); @@ -1619,11 +1083,11 @@ hash_table<Descriptor, Allocator, true> template<typename Descriptor, template<typename Type> class Allocator> template<typename Argument, - int (*Callback) (typename hash_table<Descriptor, Allocator, - true>::value_type *slot, - Argument argument)> + int (*Callback) + (typename hash_table<Descriptor, Allocator>::value_type *slot, + Argument argument)> void -hash_table<Descriptor, Allocator, true>::traverse_noresize (Argument argument) +hash_table<Descriptor, Allocator>::traverse_noresize (Argument argument) { value_type *slot = m_entries; value_type *limit = slot + size (); @@ -1645,11 +1109,11 @@ hash_table<Descriptor, Allocator, true>::traverse_noresize (Argument argument) template <typename Descriptor, template <typename Type> class Allocator> template <typename Argument, - int (*Callback) (typename hash_table<Descriptor, Allocator, - true>::value_type *slot, - Argument argument)> + int (*Callback) + (typename hash_table<Descriptor, Allocator>::value_type *slot, + Argument argument)> void -hash_table<Descriptor, Allocator, true>::traverse (Argument argument) +hash_table<Descriptor, Allocator>::traverse (Argument argument) { size_t size = m_size; if (elements () * 8 < size && size > 32) @@ -1662,7 +1126,7 @@ hash_table<Descriptor, Allocator, true>::traverse (Argument argument) template<typename Descriptor, template<typename Type> class Allocator> void -hash_table<Descriptor, Allocator, true>::iterator::slide () +hash_table<Descriptor, Allocator>::iterator::slide () { for ( ; m_slot < m_limit; ++m_slot ) { @@ -1677,8 +1141,8 @@ hash_table<Descriptor, Allocator, true>::iterator::slide () /* Bump the iterator. */ template<typename Descriptor, template<typename Type> class Allocator> -inline typename hash_table<Descriptor, Allocator, true>::iterator & -hash_table<Descriptor, Allocator, true>::iterator::operator ++ () +inline typename hash_table<Descriptor, Allocator>::iterator & +hash_table<Descriptor, Allocator>::iterator::operator ++ () { ++m_slot; slide (); diff --git a/gcc/ipa-devirt.c b/gcc/ipa-devirt.c index 6969f5a..7214a74 100644 --- a/gcc/ipa-devirt.c +++ b/gcc/ipa-devirt.c @@ -308,11 +308,11 @@ type_possibly_instantiated_p (tree t) struct odr_name_hasher { - typedef odr_type_d value_type; - typedef union tree_node compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); - static inline void remove (value_type *); + typedef odr_type_d *value_type; + typedef union tree_node *compare_type; + static inline hashval_t hash (const odr_type_d *); + static inline bool equal (const odr_type_d *, const tree_node *); + static inline void remove (odr_type_d *); }; /* Has used to unify ODR types based on their associated virtual table. @@ -321,8 +321,8 @@ struct odr_name_hasher struct odr_vtable_hasher:odr_name_hasher { - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + static inline hashval_t hash (const odr_type_d *); + static inline bool equal (const odr_type_d *, const tree_node *); }; /* Return type that was declared with T's name so that T is an @@ -369,7 +369,7 @@ hash_odr_name (const_tree t) /* Return the computed hashcode for ODR_TYPE. */ inline hashval_t -odr_name_hasher::hash (const value_type *odr_type) +odr_name_hasher::hash (const odr_type_d *odr_type) { return hash_odr_name (odr_type->type); } @@ -414,7 +414,7 @@ hash_odr_vtable (const_tree t) /* Return the computed hashcode for ODR_TYPE. */ inline hashval_t -odr_vtable_hasher::hash (const value_type *odr_type) +odr_vtable_hasher::hash (const odr_type_d *odr_type) { return hash_odr_vtable (odr_type->type); } @@ -553,7 +553,7 @@ types_must_be_same_for_odr (tree t1, tree t2) equivalent. */ inline bool -odr_name_hasher::equal (const value_type *o1, const compare_type *t2) +odr_name_hasher::equal (const odr_type_d *o1, const tree_node *t2) { tree t1 = o1->type; @@ -578,7 +578,7 @@ odr_name_hasher::equal (const value_type *o1, const compare_type *t2) equivalent. */ inline bool -odr_vtable_hasher::equal (const value_type *o1, const compare_type *t2) +odr_vtable_hasher::equal (const odr_type_d *o1, const tree_node *t2) { tree t1 = o1->type; @@ -602,7 +602,7 @@ odr_vtable_hasher::equal (const value_type *o1, const compare_type *t2) /* Free ODR type V. */ inline void -odr_name_hasher::remove (value_type *v) +odr_name_hasher::remove (odr_type_d *v) { v->bases.release (); v->derived_types.release (); @@ -2507,17 +2507,18 @@ struct polymorphic_call_target_d struct polymorphic_call_target_hasher { - typedef polymorphic_call_target_d value_type; - typedef polymorphic_call_target_d compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); - static inline void remove (value_type *); + typedef polymorphic_call_target_d *value_type; + typedef polymorphic_call_target_d *compare_type; + static inline hashval_t hash (const polymorphic_call_target_d *); + static inline bool equal (const polymorphic_call_target_d *, + const polymorphic_call_target_d *); + static inline void remove (polymorphic_call_target_d *); }; /* Return the computed hashcode for ODR_QUERY. */ inline hashval_t -polymorphic_call_target_hasher::hash (const value_type *odr_query) +polymorphic_call_target_hasher::hash (const polymorphic_call_target_d *odr_query) { inchash::hash hstate (odr_query->otr_token); @@ -2541,8 +2542,8 @@ polymorphic_call_target_hasher::hash (const value_type *odr_query) /* Compare cache entries T1 and T2. */ inline bool -polymorphic_call_target_hasher::equal (const value_type *t1, - const compare_type *t2) +polymorphic_call_target_hasher::equal (const polymorphic_call_target_d *t1, + const polymorphic_call_target_d *t2) { return (t1->type == t2->type && t1->otr_token == t2->otr_token && t1->speculative == t2->speculative @@ -2560,7 +2561,7 @@ polymorphic_call_target_hasher::equal (const value_type *t1, /* Remove entry in polymorphic call target cache hash. */ inline void -polymorphic_call_target_hasher::remove (value_type *v) +polymorphic_call_target_hasher::remove (polymorphic_call_target_d *v) { v->targets.release (); free (v); diff --git a/gcc/ipa-icf.h b/gcc/ipa-icf.h index 7eb9f27..b9d70b4 100644 --- a/gcc/ipa-icf.h +++ b/gcc/ipa-icf.h @@ -429,15 +429,16 @@ struct congruence_class_group /* Congruence class set structure. */ struct congruence_class_group_hash: typed_noop_remove <congruence_class_group> { - typedef congruence_class_group value_type; - typedef congruence_class_group compare_type; + typedef congruence_class_group *value_type; + typedef congruence_class_group *compare_type; - static inline hashval_t hash (const value_type *item) + static inline hashval_t hash (const congruence_class_group *item) { return item->hash; } - static inline int equal (const value_type *item1, const compare_type *item2) + static inline int equal (const congruence_class_group *item1, + const congruence_class_group *item2) { return item1->hash == item2->hash && item1->type == item2->type; } diff --git a/gcc/ipa-profile.c b/gcc/ipa-profile.c index e9f937f..96fb810 100644 --- a/gcc/ipa-profile.c +++ b/gcc/ipa-profile.c @@ -113,10 +113,10 @@ static alloc_pool histogram_pool; struct histogram_hash : typed_noop_remove <histogram_entry> { - typedef histogram_entry value_type; - typedef histogram_entry compare_type; - static inline hashval_t hash (const value_type *); - static inline int equal (const value_type *, const compare_type *); + typedef histogram_entry *value_type; + typedef histogram_entry *compare_type; + static inline hashval_t hash (const histogram_entry *); + static inline int equal (const histogram_entry *, const histogram_entry *); }; inline hashval_t diff --git a/gcc/ira-color.c b/gcc/ira-color.c index ff1fe8a..bc0692d 100644 --- a/gcc/ira-color.c +++ b/gcc/ira-color.c @@ -227,22 +227,24 @@ static vec<allocno_hard_regs_t> allocno_hard_regs_vec; struct allocno_hard_regs_hasher : typed_noop_remove <allocno_hard_regs> { - typedef allocno_hard_regs value_type; - typedef allocno_hard_regs compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef allocno_hard_regs *value_type; + typedef allocno_hard_regs *compare_type; + static inline hashval_t hash (const allocno_hard_regs *); + static inline bool equal (const allocno_hard_regs *, + const allocno_hard_regs *); }; /* Returns hash value for allocno hard registers V. */ inline hashval_t -allocno_hard_regs_hasher::hash (const value_type *hv) +allocno_hard_regs_hasher::hash (const allocno_hard_regs *hv) { return iterative_hash (&hv->set, sizeof (HARD_REG_SET), 0); } /* Compares allocno hard registers V1 and V2. */ inline bool -allocno_hard_regs_hasher::equal (const value_type *hv1, const compare_type *hv2) +allocno_hard_regs_hasher::equal (const allocno_hard_regs *hv1, + const allocno_hard_regs *hv2) { return hard_reg_set_equal_p (hv1->set, hv2->set); } diff --git a/gcc/ira-costs.c b/gcc/ira-costs.c index 354ba6b..5358440 100644 --- a/gcc/ira-costs.c +++ b/gcc/ira-costs.c @@ -161,23 +161,23 @@ static cost_classes_t *regno_cost_classes; struct cost_classes_hasher { - typedef cost_classes value_type; - typedef cost_classes compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); - static inline void remove (value_type *); + typedef cost_classes *value_type; + typedef cost_classes *compare_type; + static inline hashval_t hash (const cost_classes *); + static inline bool equal (const cost_classes *, const cost_classes *); + static inline void remove (cost_classes *); }; /* Returns hash value for cost classes info HV. */ inline hashval_t -cost_classes_hasher::hash (const value_type *hv) +cost_classes_hasher::hash (const cost_classes *hv) { return iterative_hash (&hv->classes, sizeof (enum reg_class) * hv->num, 0); } /* Compares cost classes info HV1 and HV2. */ inline bool -cost_classes_hasher::equal (const value_type *hv1, const compare_type *hv2) +cost_classes_hasher::equal (const cost_classes *hv1, const cost_classes *hv2) { return (hv1->num == hv2->num && memcmp (hv1->classes, hv2->classes, @@ -186,7 +186,7 @@ cost_classes_hasher::equal (const value_type *hv1, const compare_type *hv2) /* Delete cost classes info V from the hash table. */ inline void -cost_classes_hasher::remove (value_type *v) +cost_classes_hasher::remove (cost_classes *v) { ira_free (v); } diff --git a/gcc/java/jcf-io.c b/gcc/java/jcf-io.c index 2c48f14..36ceb07 100644 --- a/gcc/java/jcf-io.c +++ b/gcc/java/jcf-io.c @@ -285,21 +285,20 @@ find_classfile (char *filename, JCF *jcf, const char *dep_name) struct charstar_hash : typed_noop_remove <char> { - typedef const char value_type; - typedef const char compare_type; - static inline hashval_t hash (const value_type *candidate); - static inline bool equal (const value_type *existing, - const compare_type *candidate); + typedef const char *value_type; + typedef const char *compare_type; + static inline hashval_t hash (const char *candidate); + static inline bool equal (const char *existing, const char *candidate); }; inline hashval_t -charstar_hash::hash (const value_type *candidate) +charstar_hash::hash (const char *candidate) { return htab_hash_string (candidate); } inline bool -charstar_hash::equal (const value_type *existing, const compare_type *candidate) +charstar_hash::equal (const char *existing, const char *candidate) { return strcmp (existing, candidate) == 0; } diff --git a/gcc/loop-invariant.c b/gcc/loop-invariant.c index f79b497..52ecc05 100644 --- a/gcc/loop-invariant.c +++ b/gcc/loop-invariant.c @@ -455,16 +455,17 @@ invariant_expr_equal_p (rtx_insn *insn1, rtx e1, rtx_insn *insn2, rtx e2) struct invariant_expr_hasher : typed_free_remove <invariant_expr_entry> { - typedef invariant_expr_entry value_type; - typedef invariant_expr_entry compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef invariant_expr_entry *value_type; + typedef invariant_expr_entry *compare_type; + static inline hashval_t hash (const invariant_expr_entry *); + static inline bool equal (const invariant_expr_entry *, + const invariant_expr_entry *); }; /* Returns hash value for invariant expression entry ENTRY. */ inline hashval_t -invariant_expr_hasher::hash (const value_type *entry) +invariant_expr_hasher::hash (const invariant_expr_entry *entry) { return entry->hash; } @@ -472,8 +473,8 @@ invariant_expr_hasher::hash (const value_type *entry) /* Compares invariant expression entries ENTRY1 and ENTRY2. */ inline bool -invariant_expr_hasher::equal (const value_type *entry1, - const compare_type *entry2) +invariant_expr_hasher::equal (const invariant_expr_entry *entry1, + const invariant_expr_entry *entry2) { if (entry1->mode != entry2->mode) return 0; diff --git a/gcc/loop-iv.c b/gcc/loop-iv.c index de2b15a..36a9a9f 100644 --- a/gcc/loop-iv.c +++ b/gcc/loop-iv.c @@ -138,16 +138,16 @@ static struct loop *current_loop; struct biv_entry_hasher : typed_free_remove <biv_entry> { - typedef biv_entry value_type; - typedef rtx_def compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef biv_entry *value_type; + typedef rtx_def *compare_type; + static inline hashval_t hash (const biv_entry *); + static inline bool equal (const biv_entry *, const rtx_def *); }; /* Returns hash value for biv B. */ inline hashval_t -biv_entry_hasher::hash (const value_type *b) +biv_entry_hasher::hash (const biv_entry *b) { return b->regno; } @@ -155,7 +155,7 @@ biv_entry_hasher::hash (const value_type *b) /* Compares biv B and register R. */ inline bool -biv_entry_hasher::equal (const value_type *b, const compare_type *r) +biv_entry_hasher::equal (const biv_entry *b, const rtx_def *r) { return b->regno == REGNO (r); } diff --git a/gcc/loop-unroll.c b/gcc/loop-unroll.c index 2befb61..ccf473d 100644 --- a/gcc/loop-unroll.c +++ b/gcc/loop-unroll.c @@ -126,17 +126,17 @@ struct var_to_expand struct iv_split_hasher : typed_free_remove <iv_to_split> { - typedef iv_to_split value_type; - typedef iv_to_split compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef iv_to_split *value_type; + typedef iv_to_split *compare_type; + static inline hashval_t hash (const iv_to_split *); + static inline bool equal (const iv_to_split *, const iv_to_split *); }; /* A hash function for information about insns to split. */ inline hashval_t -iv_split_hasher::hash (const value_type *ivts) +iv_split_hasher::hash (const iv_to_split *ivts) { return (hashval_t) INSN_UID (ivts->insn); } @@ -144,7 +144,7 @@ iv_split_hasher::hash (const value_type *ivts) /* An equality functions for information about insns to split. */ inline bool -iv_split_hasher::equal (const value_type *i1, const compare_type *i2) +iv_split_hasher::equal (const iv_to_split *i1, const iv_to_split *i2) { return i1->insn == i2->insn; } @@ -153,16 +153,16 @@ iv_split_hasher::equal (const value_type *i1, const compare_type *i2) struct var_expand_hasher : typed_free_remove <var_to_expand> { - typedef var_to_expand value_type; - typedef var_to_expand compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef var_to_expand *value_type; + typedef var_to_expand *compare_type; + static inline hashval_t hash (const var_to_expand *); + static inline bool equal (const var_to_expand *, const var_to_expand *); }; /* Return a hash for VES. */ inline hashval_t -var_expand_hasher::hash (const value_type *ves) +var_expand_hasher::hash (const var_to_expand *ves) { return (hashval_t) INSN_UID (ves->insn); } @@ -170,7 +170,7 @@ var_expand_hasher::hash (const value_type *ves) /* Return true if I1 and I2 refer to the same instruction. */ inline bool -var_expand_hasher::equal (const value_type *i1, const compare_type *i2) +var_expand_hasher::equal (const var_to_expand *i1, const var_to_expand *i2) { return i1->insn == i2->insn; } diff --git a/gcc/lto-streamer.h b/gcc/lto-streamer.h index b383631..e3465a8 100644 --- a/gcc/lto-streamer.h +++ b/gcc/lto-streamer.h @@ -657,17 +657,17 @@ struct string_slot struct string_slot_hasher : typed_noop_remove <string_slot> { - typedef string_slot value_type; - typedef string_slot compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef string_slot *value_type; + typedef string_slot *compare_type; + static inline hashval_t hash (const string_slot *); + static inline bool equal (const string_slot *, const string_slot *); }; /* Returns a hash code for DS. Adapted from libiberty's htab_hash_string to support strings that may not end in '\0'. */ inline hashval_t -string_slot_hasher::hash (const value_type *ds) +string_slot_hasher::hash (const string_slot *ds) { hashval_t r = ds->len; int i; @@ -680,7 +680,7 @@ string_slot_hasher::hash (const value_type *ds) /* Returns nonzero if DS1 and DS2 are equal. */ inline bool -string_slot_hasher::equal (const value_type *ds1, const compare_type *ds2) +string_slot_hasher::equal (const string_slot *ds1, const string_slot *ds2) { if (ds1->len == ds2->len) return memcmp (ds1->s, ds2->s, ds1->len) == 0; diff --git a/gcc/lto/lto.c b/gcc/lto/lto.c index 360aeed..f3458c7 100644 --- a/gcc/lto/lto.c +++ b/gcc/lto/lto.c @@ -1143,20 +1143,20 @@ struct tree_scc struct tree_scc_hasher : typed_noop_remove <tree_scc> { - typedef tree_scc value_type; - typedef tree_scc compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef tree_scc *value_type; + typedef tree_scc *compare_type; + static inline hashval_t hash (const tree_scc *); + static inline bool equal (const tree_scc *, const tree_scc *); }; hashval_t -tree_scc_hasher::hash (const value_type *scc) +tree_scc_hasher::hash (const tree_scc *scc) { return scc->hash; } bool -tree_scc_hasher::equal (const value_type *scc1, const compare_type *scc2) +tree_scc_hasher::equal (const tree_scc *scc1, const tree_scc *scc2) { if (scc1->hash != scc2->hash || scc1->len != scc2->len diff --git a/gcc/objc/objc-act.c b/gcc/objc/objc-act.c index 6bd4dcc..718fdf0 100644 --- a/gcc/objc/objc-act.c +++ b/gcc/objc/objc-act.c @@ -3871,20 +3871,20 @@ objc_get_class_ivars (tree class_name) struct decl_name_hash : typed_noop_remove <tree_node> { - typedef tree_node value_type; - typedef tree_node compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef tree_node *value_type; + typedef tree_node *compare_type; + static inline hashval_t hash (const tree_node *); + static inline bool equal (const tree_node *, const tree_node *); }; inline hashval_t -decl_name_hash::hash (const value_type *q) +decl_name_hash::hash (const tree_node *q) { return (hashval_t) ((intptr_t)(DECL_NAME (q)) >> 3); } inline bool -decl_name_hash::equal (const value_type *a, const compare_type *b) +decl_name_hash::equal (const tree_node *a, const tree_node *b) { return DECL_NAME (a) == DECL_NAME (b); } diff --git a/gcc/plugin.c b/gcc/plugin.c index d924438..6a7654f 100644 --- a/gcc/plugin.c +++ b/gcc/plugin.c @@ -66,16 +66,16 @@ const char **plugin_event_name = plugin_event_name_init; struct event_hasher : typed_noop_remove <const char *> { - typedef const char *value_type; - typedef const char *compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef const char **value_type; + typedef const char **compare_type; + static inline hashval_t hash (const char **); + static inline bool equal (const char **, const char **); }; /* Helper function for the event hash table that hashes the entry V. */ inline hashval_t -event_hasher::hash (const value_type *v) +event_hasher::hash (const char **v) { return htab_hash_string (*v); } @@ -84,7 +84,7 @@ event_hasher::hash (const value_type *v) existing entry (S1) with the given string (S2). */ inline bool -event_hasher::equal (const value_type *s1, const compare_type *s2) +event_hasher::equal (const char **s1, const char **s2) { return !strcmp (*s1, *s2); } diff --git a/gcc/postreload-gcse.c b/gcc/postreload-gcse.c index 83048bd..9014d69 100644 --- a/gcc/postreload-gcse.c +++ b/gcc/postreload-gcse.c @@ -134,10 +134,10 @@ struct expr struct expr_hasher : typed_noop_remove <expr> { - typedef expr value_type; - typedef expr compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef expr *value_type; + typedef expr *compare_type; + static inline hashval_t hash (const expr *); + static inline bool equal (const expr *, const expr *); }; @@ -159,7 +159,7 @@ hash_expr (rtx x, int *do_not_record_p) here, we just return the cached hash value. */ inline hashval_t -expr_hasher::hash (const value_type *exp) +expr_hasher::hash (const expr *exp) { return exp->hash; } @@ -168,7 +168,7 @@ expr_hasher::hash (const value_type *exp) Return nonzero if exp1 is equivalent to exp2. */ inline bool -expr_hasher::equal (const value_type *exp1, const compare_type *exp2) +expr_hasher::equal (const expr *exp1, const expr *exp2) { int equiv_p = exp_equiv_p (exp1->expr, exp2->expr, 0, true); diff --git a/gcc/reginfo.c b/gcc/reginfo.c index 9015eeb..6678688 100644 --- a/gcc/reginfo.c +++ b/gcc/reginfo.c @@ -85,15 +85,6 @@ struct simplifiable_subreg subreg_shape shape; HARD_REG_SET simplifiable_regs; }; - -struct simplifiable_subregs_hasher : typed_noop_remove <simplifiable_subreg> -{ - typedef simplifiable_subreg value_type; - typedef subreg_shape compare_type; - - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); -}; struct target_hard_regs default_target_hard_regs; struct target_regs default_target_regs; @@ -1234,14 +1225,14 @@ reg_classes_intersect_p (reg_class_t c1, reg_class_t c2) inline hashval_t -simplifiable_subregs_hasher::hash (const value_type *value) +simplifiable_subregs_hasher::hash (const simplifiable_subreg *value) { return value->shape.unique_id (); } inline bool -simplifiable_subregs_hasher::equal (const value_type *value, - const compare_type *compare) +simplifiable_subregs_hasher::equal (const simplifiable_subreg *value, + const subreg_shape *compare) { return value->shape == *compare; } diff --git a/gcc/statistics.c b/gcc/statistics.c index b76de15..8cbe88d 100644 --- a/gcc/statistics.c +++ b/gcc/statistics.c @@ -55,17 +55,18 @@ typedef struct statistics_counter_s { struct stats_counter_hasher { - typedef statistics_counter_t value_type; - typedef statistics_counter_t compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); - static inline void remove (value_type *); + typedef statistics_counter_t *value_type; + typedef statistics_counter_t *compare_type; + static inline hashval_t hash (const statistics_counter_t *); + static inline bool equal (const statistics_counter_t *, + const statistics_counter_t *); + static inline void remove (statistics_counter_t *); }; /* Hash a statistic counter by its string ID. */ inline hashval_t -stats_counter_hasher::hash (const value_type *c) +stats_counter_hasher::hash (const statistics_counter_t *c) { return htab_hash_string (c->id) + c->val; } @@ -73,7 +74,8 @@ stats_counter_hasher::hash (const value_type *c) /* Compare two statistic counters by their string IDs. */ inline bool -stats_counter_hasher::equal (const value_type *c1, const compare_type *c2) +stats_counter_hasher::equal (const statistics_counter_t *c1, + const statistics_counter_t *c2) { return c1->val == c2->val && strcmp (c1->id, c2->id) == 0; } @@ -81,7 +83,7 @@ stats_counter_hasher::equal (const value_type *c1, const compare_type *c2) /* Free a statistics entry. */ inline void -stats_counter_hasher::remove (value_type *v) +stats_counter_hasher::remove (statistics_counter_t *v) { free (CONST_CAST (char *, v->id)); free (v); diff --git a/gcc/store-motion.c b/gcc/store-motion.c index 530766f..d621ec1 100644 --- a/gcc/store-motion.c +++ b/gcc/store-motion.c @@ -137,21 +137,21 @@ static struct edge_list *edge_list; struct st_expr_hasher : typed_noop_remove <st_expr> { - typedef st_expr value_type; - typedef st_expr compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef st_expr *value_type; + typedef st_expr *compare_type; + static inline hashval_t hash (const st_expr *); + static inline bool equal (const st_expr *, const st_expr *); }; inline hashval_t -st_expr_hasher::hash (const value_type *x) +st_expr_hasher::hash (const st_expr *x) { int do_not_record_p = 0; return hash_rtx (x->pattern, GET_MODE (x->pattern), &do_not_record_p, NULL, false); } inline bool -st_expr_hasher::equal (const value_type *ptr1, const compare_type *ptr2) +st_expr_hasher::equal (const st_expr *ptr1, const st_expr *ptr2) { return exp_equiv_p (ptr1->pattern, ptr2->pattern, 0, true); } diff --git a/gcc/trans-mem.c b/gcc/trans-mem.c index 078c2da..d6cbd76 100644 --- a/gcc/trans-mem.c +++ b/gcc/trans-mem.c @@ -974,23 +974,23 @@ typedef struct tm_log_entry struct log_entry_hasher { - typedef tm_log_entry value_type; - typedef tm_log_entry compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); - static inline void remove (value_type *); + typedef tm_log_entry *value_type; + typedef tm_log_entry *compare_type; + static inline hashval_t hash (const tm_log_entry *); + static inline bool equal (const tm_log_entry *, const tm_log_entry *); + static inline void remove (tm_log_entry *); }; /* Htab support. Return hash value for a `tm_log_entry'. */ inline hashval_t -log_entry_hasher::hash (const value_type *log) +log_entry_hasher::hash (const tm_log_entry *log) { return iterative_hash_expr (log->addr, 0); } /* Htab support. Return true if two log entries are the same. */ inline bool -log_entry_hasher::equal (const value_type *log1, const compare_type *log2) +log_entry_hasher::equal (const tm_log_entry *log1, const tm_log_entry *log2) { /* FIXME: @@ -1016,7 +1016,7 @@ log_entry_hasher::equal (const value_type *log1, const compare_type *log2) /* Htab support. Free one tm_log_entry. */ inline void -log_entry_hasher::remove (value_type *lp) +log_entry_hasher::remove (tm_log_entry *lp) { lp->stmts.release (); free (lp); @@ -1049,20 +1049,20 @@ typedef struct tm_new_mem_map struct tm_mem_map_hasher : typed_free_remove <tm_new_mem_map_t> { - typedef tm_new_mem_map_t value_type; - typedef tm_new_mem_map_t compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef tm_new_mem_map_t *value_type; + typedef tm_new_mem_map_t *compare_type; + static inline hashval_t hash (const tm_new_mem_map_t *); + static inline bool equal (const tm_new_mem_map_t *, const tm_new_mem_map_t *); }; inline hashval_t -tm_mem_map_hasher::hash (const value_type *v) +tm_mem_map_hasher::hash (const tm_new_mem_map_t *v) { return (intptr_t)v->val >> 4; } inline bool -tm_mem_map_hasher::equal (const value_type *v, const compare_type *c) +tm_mem_map_hasher::equal (const tm_new_mem_map_t *v, const tm_new_mem_map_t *c) { return v->val == c->val; } @@ -3350,15 +3350,15 @@ typedef struct tm_memop struct tm_memop_hasher : typed_free_remove <tm_memop> { - typedef tm_memop value_type; - typedef tm_memop compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef tm_memop *value_type; + typedef tm_memop *compare_type; + static inline hashval_t hash (const tm_memop *); + static inline bool equal (const tm_memop *, const tm_memop *); }; /* Htab support. Return a hash value for a `tm_memop'. */ inline hashval_t -tm_memop_hasher::hash (const value_type *mem) +tm_memop_hasher::hash (const tm_memop *mem) { tree addr = mem->addr; /* We drill down to the SSA_NAME/DECL for the hash, but equality is @@ -3370,7 +3370,7 @@ tm_memop_hasher::hash (const value_type *mem) /* Htab support. Return true if two tm_memop's are the same. */ inline bool -tm_memop_hasher::equal (const value_type *mem1, const compare_type *mem2) +tm_memop_hasher::equal (const tm_memop *mem1, const tm_memop *mem2) { return operand_equal_p (mem1->addr, mem2->addr, 0); } diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c index 64bdc92..c03dfed 100644 --- a/gcc/tree-cfg.c +++ b/gcc/tree-cfg.c @@ -148,17 +148,18 @@ struct locus_discrim_map struct locus_discrim_hasher : typed_free_remove <locus_discrim_map> { - typedef locus_discrim_map value_type; - typedef locus_discrim_map compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef locus_discrim_map *value_type; + typedef locus_discrim_map *compare_type; + static inline hashval_t hash (const locus_discrim_map *); + static inline bool equal (const locus_discrim_map *, + const locus_discrim_map *); }; /* Trivial hash function for a location_t. ITEM is a pointer to a hash table entry that maps a location_t to a discriminator. */ inline hashval_t -locus_discrim_hasher::hash (const value_type *item) +locus_discrim_hasher::hash (const locus_discrim_map *item) { return LOCATION_LINE (item->locus); } @@ -167,7 +168,8 @@ locus_discrim_hasher::hash (const value_type *item) point to the two hash table entries to compare. */ inline bool -locus_discrim_hasher::equal (const value_type *a, const compare_type *b) +locus_discrim_hasher::equal (const locus_discrim_map *a, + const locus_discrim_map *b) { return LOCATION_LINE (a->locus) == LOCATION_LINE (b->locus); } diff --git a/gcc/tree-eh.c b/gcc/tree-eh.c index a111e9d..5d41cb4 100644 --- a/gcc/tree-eh.c +++ b/gcc/tree-eh.c @@ -214,20 +214,22 @@ struct finally_tree_node struct finally_tree_hasher : typed_free_remove <finally_tree_node> { - typedef finally_tree_node value_type; - typedef finally_tree_node compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef finally_tree_node *value_type; + typedef finally_tree_node *compare_type; + static inline hashval_t hash (const finally_tree_node *); + static inline bool equal (const finally_tree_node *, + const finally_tree_node *); }; inline hashval_t -finally_tree_hasher::hash (const value_type *v) +finally_tree_hasher::hash (const finally_tree_node *v) { return (intptr_t)v->child.t >> 4; } inline bool -finally_tree_hasher::equal (const value_type *v, const compare_type *c) +finally_tree_hasher::equal (const finally_tree_node *v, + const finally_tree_node *c) { return v->child.t == c->child.t; } diff --git a/gcc/tree-hasher.h b/gcc/tree-hasher.h index 35eb9b2..228e317 100644 --- a/gcc/tree-hasher.h +++ b/gcc/tree-hasher.h @@ -34,7 +34,6 @@ struct int_tree_hasher { typedef int_tree_map value_type; typedef int_tree_map compare_type; - typedef int store_values_directly; static inline hashval_t hash (const value_type &); static inline bool equal (const value_type &, const compare_type &); static bool is_deleted (const value_type &v) diff --git a/gcc/tree-into-ssa.c b/gcc/tree-into-ssa.c index 2589628..e8b55c1 100644 --- a/gcc/tree-into-ssa.c +++ b/gcc/tree-into-ssa.c @@ -232,7 +232,6 @@ struct var_info_hasher : typed_free_remove <var_info_d> { typedef var_info_d *value_type; typedef var_info_d *compare_type; - typedef int store_values_directly; static inline hashval_t hash (const value_type &); static inline bool equal (const value_type &, const compare_type &); }; diff --git a/gcc/tree-parloops.c b/gcc/tree-parloops.c index 62a6444..080d35e 100644 --- a/gcc/tree-parloops.c +++ b/gcc/tree-parloops.c @@ -228,22 +228,22 @@ struct reduction_info struct reduction_hasher : typed_free_remove <reduction_info> { - typedef reduction_info value_type; - typedef reduction_info compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef reduction_info *value_type; + typedef reduction_info *compare_type; + static inline hashval_t hash (const reduction_info *); + static inline bool equal (const reduction_info *, const reduction_info *); }; /* Equality and hash functions for hashtab code. */ inline bool -reduction_hasher::equal (const value_type *a, const compare_type *b) +reduction_hasher::equal (const reduction_info *a, const reduction_info *b) { return (a->reduc_phi == b->reduc_phi); } inline hashval_t -reduction_hasher::hash (const value_type *a) +reduction_hasher::hash (const reduction_info *a) { return a->reduc_version; } @@ -280,22 +280,22 @@ struct name_to_copy_elt struct name_to_copy_hasher : typed_free_remove <name_to_copy_elt> { - typedef name_to_copy_elt value_type; - typedef name_to_copy_elt compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef name_to_copy_elt *value_type; + typedef name_to_copy_elt *compare_type; + static inline hashval_t hash (const name_to_copy_elt *); + static inline bool equal (const name_to_copy_elt *, const name_to_copy_elt *); }; /* Equality and hash functions for hashtab code. */ inline bool -name_to_copy_hasher::equal (const value_type *a, const compare_type *b) +name_to_copy_hasher::equal (const name_to_copy_elt *a, const name_to_copy_elt *b) { return a->version == b->version; } inline hashval_t -name_to_copy_hasher::hash (const value_type *a) +name_to_copy_hasher::hash (const name_to_copy_elt *a) { return (hashval_t) a->version; } diff --git a/gcc/tree-sra.c b/gcc/tree-sra.c index 6adee70..4b0d2a8 100644 --- a/gcc/tree-sra.c +++ b/gcc/tree-sra.c @@ -327,16 +327,16 @@ static hash_map<tree, auto_vec<access_p> > *base_access_vec; struct uid_decl_hasher : typed_noop_remove <tree_node> { - typedef tree_node value_type; - typedef tree_node compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef tree_node *value_type; + typedef tree_node *compare_type; + static inline hashval_t hash (const tree_node *); + static inline bool equal (const tree_node *, const tree_node *); }; /* Hash a tree in a uid_decl_map. */ inline hashval_t -uid_decl_hasher::hash (const value_type *item) +uid_decl_hasher::hash (const tree_node *item) { return item->decl_minimal.uid; } @@ -344,7 +344,7 @@ uid_decl_hasher::hash (const value_type *item) /* Return true if the DECL_UID in both trees are equal. */ inline bool -uid_decl_hasher::equal (const value_type *a, const compare_type *b) +uid_decl_hasher::equal (const tree_node *a, const tree_node *b) { return (a->decl_minimal.uid == b->decl_minimal.uid); } diff --git a/gcc/tree-ssa-coalesce.c b/gcc/tree-ssa-coalesce.c index 1afeefe..eeac5a4 100644 --- a/gcc/tree-ssa-coalesce.c +++ b/gcc/tree-ssa-coalesce.c @@ -81,16 +81,16 @@ typedef const struct coalesce_pair *const_coalesce_pair_p; struct coalesce_pair_hasher : typed_noop_remove <coalesce_pair> { - typedef coalesce_pair value_type; - typedef coalesce_pair compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef coalesce_pair *value_type; + typedef coalesce_pair *compare_type; + static inline hashval_t hash (const coalesce_pair *); + static inline bool equal (const coalesce_pair *, const coalesce_pair *); }; /* Hash function for coalesce list. Calculate hash for PAIR. */ inline hashval_t -coalesce_pair_hasher::hash (const value_type *pair) +coalesce_pair_hasher::hash (const coalesce_pair *pair) { hashval_t a = (hashval_t)(pair->first_element); hashval_t b = (hashval_t)(pair->second_element); @@ -102,7 +102,7 @@ coalesce_pair_hasher::hash (const value_type *pair) returning TRUE if the two pairs are equivalent. */ inline bool -coalesce_pair_hasher::equal (const value_type *p1, const compare_type *p2) +coalesce_pair_hasher::equal (const coalesce_pair *p1, const coalesce_pair *p2) { return (p1->first_element == p2->first_element && p1->second_element == p2->second_element); @@ -1253,10 +1253,10 @@ coalesce_partitions (var_map map, ssa_conflicts_p graph, coalesce_list_p cl, struct ssa_name_var_hash : typed_noop_remove <tree_node> { - typedef union tree_node value_type; - typedef union tree_node compare_type; - static inline hashval_t hash (const value_type *); - static inline int equal (const value_type *, const compare_type *); + typedef union tree_node *value_type; + typedef union tree_node *compare_type; + static inline hashval_t hash (const tree_node *); + static inline int equal (const tree_node *, const tree_node *); }; inline hashval_t @@ -1266,7 +1266,7 @@ ssa_name_var_hash::hash (const_tree n) } inline int -ssa_name_var_hash::equal (const value_type *n1, const compare_type *n2) +ssa_name_var_hash::equal (const tree_node *n1, const tree_node *n2) { return SSA_NAME_VAR (n1) == SSA_NAME_VAR (n2); } diff --git a/gcc/tree-ssa-dom.c b/gcc/tree-ssa-dom.c index 907fa97..c526b58 100644 --- a/gcc/tree-ssa-dom.c +++ b/gcc/tree-ssa-dom.c @@ -182,7 +182,6 @@ struct expr_elt_hasher { typedef expr_hash_elt *value_type; typedef expr_hash_elt *compare_type; - typedef int store_values_directly; static inline hashval_t hash (const value_type &); static inline bool equal (const value_type &, const compare_type &); static inline void remove (value_type &); diff --git a/gcc/tree-ssa-live.c b/gcc/tree-ssa-live.c index df90229..2c7c072 100644 --- a/gcc/tree-ssa-live.c +++ b/gcc/tree-ssa-live.c @@ -104,20 +104,20 @@ static void verify_live_on_entry (tree_live_info_p); struct tree_int_map_hasher : typed_noop_remove <tree_int_map> { - typedef tree_int_map value_type; - typedef tree_int_map compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef tree_int_map *value_type; + typedef tree_int_map *compare_type; + static inline hashval_t hash (const tree_int_map *); + static inline bool equal (const tree_int_map *, const tree_int_map *); }; inline hashval_t -tree_int_map_hasher::hash (const value_type *v) +tree_int_map_hasher::hash (const tree_int_map *v) { return tree_map_base_hash (v); } inline bool -tree_int_map_hasher::equal (const value_type *v, const compare_type *c) +tree_int_map_hasher::equal (const tree_int_map *v, const tree_int_map *c) { return tree_int_map_eq (v, c); } diff --git a/gcc/tree-ssa-loop-im.c b/gcc/tree-ssa-loop-im.c index 9aba79b..11fc699 100644 --- a/gcc/tree-ssa-loop-im.c +++ b/gcc/tree-ssa-loop-im.c @@ -172,16 +172,16 @@ typedef struct im_mem_ref struct mem_ref_hasher : typed_noop_remove <im_mem_ref> { - typedef im_mem_ref value_type; - typedef tree_node compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef im_mem_ref *value_type; + typedef tree_node *compare_type; + static inline hashval_t hash (const im_mem_ref *); + static inline bool equal (const im_mem_ref *, const tree_node *); }; /* A hash function for struct im_mem_ref object OBJ. */ inline hashval_t -mem_ref_hasher::hash (const value_type *mem) +mem_ref_hasher::hash (const im_mem_ref *mem) { return mem->hash; } @@ -190,7 +190,7 @@ mem_ref_hasher::hash (const value_type *mem) memory reference OBJ2. */ inline bool -mem_ref_hasher::equal (const value_type *mem1, const compare_type *obj2) +mem_ref_hasher::equal (const im_mem_ref *mem1, const tree_node *obj2) { return operand_equal_p (mem1->mem.ref, (const_tree) obj2, 0); } diff --git a/gcc/tree-ssa-loop-ivopts.c b/gcc/tree-ssa-loop-ivopts.c index 6c96430..d71e3a4 100644 --- a/gcc/tree-ssa-loop-ivopts.c +++ b/gcc/tree-ssa-loop-ivopts.c @@ -292,16 +292,16 @@ typedef struct iv_cand *iv_cand_p; struct iv_inv_expr_hasher : typed_free_remove <iv_inv_expr_ent> { - typedef iv_inv_expr_ent value_type; - typedef iv_inv_expr_ent compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef iv_inv_expr_ent *value_type; + typedef iv_inv_expr_ent *compare_type; + static inline hashval_t hash (const iv_inv_expr_ent *); + static inline bool equal (const iv_inv_expr_ent *, const iv_inv_expr_ent *); }; /* Hash function for loop invariant expressions. */ inline hashval_t -iv_inv_expr_hasher::hash (const value_type *expr) +iv_inv_expr_hasher::hash (const iv_inv_expr_ent *expr) { return expr->hash; } @@ -309,7 +309,8 @@ iv_inv_expr_hasher::hash (const value_type *expr) /* Hash table equality function for expressions. */ inline bool -iv_inv_expr_hasher::equal (const value_type *expr1, const compare_type *expr2) +iv_inv_expr_hasher::equal (const iv_inv_expr_ent *expr1, + const iv_inv_expr_ent *expr2) { return expr1->hash == expr2->hash && operand_equal_p (expr1->expr, expr2->expr, 0); diff --git a/gcc/tree-ssa-phiopt.c b/gcc/tree-ssa-phiopt.c index 14a7122..7c846c2 100644 --- a/gcc/tree-ssa-phiopt.c +++ b/gcc/tree-ssa-phiopt.c @@ -1332,10 +1332,10 @@ struct name_to_bb struct ssa_names_hasher : typed_free_remove <name_to_bb> { - typedef name_to_bb value_type; - typedef name_to_bb compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef name_to_bb *value_type; + typedef name_to_bb *compare_type; + static inline hashval_t hash (const name_to_bb *); + static inline bool equal (const name_to_bb *, const name_to_bb *); }; /* Used for quick clearing of the hash-table when we see calls. @@ -1345,7 +1345,7 @@ static unsigned int nt_call_phase; /* The hash function. */ inline hashval_t -ssa_names_hasher::hash (const value_type *n) +ssa_names_hasher::hash (const name_to_bb *n) { return n->ssa_name_ver ^ (((hashval_t) n->store) << 31) ^ (n->offset << 6) ^ (n->size << 3); @@ -1354,7 +1354,7 @@ ssa_names_hasher::hash (const value_type *n) /* The equality function of *P1 and *P2. */ inline bool -ssa_names_hasher::equal (const value_type *n1, const compare_type *n2) +ssa_names_hasher::equal (const name_to_bb *n1, const name_to_bb *n2) { return n1->ssa_name_ver == n2->ssa_name_ver && n1->store == n2->store diff --git a/gcc/tree-ssa-pre.c b/gcc/tree-ssa-pre.c index c985e79..d857d84 100644 --- a/gcc/tree-ssa-pre.c +++ b/gcc/tree-ssa-pre.c @@ -228,8 +228,8 @@ typedef struct pre_expr_d : typed_noop_remove <pre_expr_d> pre_expr_union u; /* hash_table support. */ - typedef pre_expr_d value_type; - typedef pre_expr_d compare_type; + typedef pre_expr_d *value_type; + typedef pre_expr_d *compare_type; static inline hashval_t hash (const pre_expr_d *); static inline int equal (const pre_expr_d *, const pre_expr_d *); } *pre_expr; @@ -242,7 +242,7 @@ typedef struct pre_expr_d : typed_noop_remove <pre_expr_d> /* Compare E1 and E1 for equality. */ inline int -pre_expr_d::equal (const value_type *e1, const compare_type *e2) +pre_expr_d::equal (const pre_expr_d *e1, const pre_expr_d *e2) { if (e1->kind != e2->kind) return false; @@ -267,7 +267,7 @@ pre_expr_d::equal (const value_type *e1, const compare_type *e2) /* Hash E. */ inline hashval_t -pre_expr_d::hash (const value_type *e) +pre_expr_d::hash (const pre_expr_d *e) { switch (e->kind) { @@ -547,10 +547,10 @@ typedef struct expr_pred_trans_d : typed_free_remove<expr_pred_trans_d> hashval_t hashcode; /* hash_table support. */ - typedef expr_pred_trans_d value_type; - typedef expr_pred_trans_d compare_type; - static inline hashval_t hash (const value_type *); - static inline int equal (const value_type *, const compare_type *); + typedef expr_pred_trans_d *value_type; + typedef expr_pred_trans_d *compare_type; + static inline hashval_t hash (const expr_pred_trans_d *); + static inline int equal (const expr_pred_trans_d *, const expr_pred_trans_d *); } *expr_pred_trans_t; typedef const struct expr_pred_trans_d *const_expr_pred_trans_t; @@ -561,8 +561,8 @@ expr_pred_trans_d::hash (const expr_pred_trans_d *e) } inline int -expr_pred_trans_d::equal (const value_type *ve1, - const compare_type *ve2) +expr_pred_trans_d::equal (const expr_pred_trans_d *ve1, + const expr_pred_trans_d *ve2) { basic_block b1 = ve1->pred; basic_block b2 = ve2->pred; diff --git a/gcc/tree-ssa-reassoc.c b/gcc/tree-ssa-reassoc.c index 77640e5..ae9d631 100644 --- a/gcc/tree-ssa-reassoc.c +++ b/gcc/tree-ssa-reassoc.c @@ -1061,7 +1061,6 @@ struct oecount_hasher { typedef int value_type; typedef int compare_type; - typedef int store_values_directly; static inline hashval_t hash (const value_type &); static inline bool equal (const value_type &, const compare_type &); static bool is_deleted (int &v) { return v == 1; } diff --git a/gcc/tree-ssa-sccvn.c b/gcc/tree-ssa-sccvn.c index 46ce285..c6a16bc 100644 --- a/gcc/tree-ssa-sccvn.c +++ b/gcc/tree-ssa-sccvn.c @@ -148,16 +148,16 @@ along with GCC; see the file COPYING3. If not see struct vn_nary_op_hasher : typed_noop_remove <vn_nary_op_s> { - typedef vn_nary_op_s value_type; - typedef vn_nary_op_s compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef vn_nary_op_s *value_type; + typedef vn_nary_op_s *compare_type; + static inline hashval_t hash (const vn_nary_op_s *); + static inline bool equal (const vn_nary_op_s *, const vn_nary_op_s *); }; /* Return the computed hashcode for nary operation P1. */ inline hashval_t -vn_nary_op_hasher::hash (const value_type *vno1) +vn_nary_op_hasher::hash (const vn_nary_op_s *vno1) { return vno1->hashcode; } @@ -166,7 +166,7 @@ vn_nary_op_hasher::hash (const value_type *vno1) equivalent. */ inline bool -vn_nary_op_hasher::equal (const value_type *vno1, const compare_type *vno2) +vn_nary_op_hasher::equal (const vn_nary_op_s *vno1, const vn_nary_op_s *vno2) { return vn_nary_op_eq (vno1, vno2); } @@ -182,17 +182,17 @@ vn_phi_eq (const_vn_phi_t const vp1, const_vn_phi_t const vp2); struct vn_phi_hasher { - typedef vn_phi_s value_type; - typedef vn_phi_s compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); - static inline void remove (value_type *); + typedef vn_phi_s *value_type; + typedef vn_phi_s *compare_type; + static inline hashval_t hash (const vn_phi_s *); + static inline bool equal (const vn_phi_s *, const vn_phi_s *); + static inline void remove (vn_phi_s *); }; /* Return the computed hashcode for phi operation P1. */ inline hashval_t -vn_phi_hasher::hash (const value_type *vp1) +vn_phi_hasher::hash (const vn_phi_s *vp1) { return vp1->hashcode; } @@ -200,7 +200,7 @@ vn_phi_hasher::hash (const value_type *vp1) /* Compare two phi entries for equality, ignoring VN_TOP arguments. */ inline bool -vn_phi_hasher::equal (const value_type *vp1, const compare_type *vp2) +vn_phi_hasher::equal (const vn_phi_s *vp1, const vn_phi_s *vp2) { return vn_phi_eq (vp1, vp2); } @@ -208,7 +208,7 @@ vn_phi_hasher::equal (const value_type *vp1, const compare_type *vp2) /* Free a phi operation structure VP. */ inline void -vn_phi_hasher::remove (value_type *phi) +vn_phi_hasher::remove (vn_phi_s *phi) { phi->phiargs.release (); } @@ -250,29 +250,29 @@ free_reference (vn_reference_s *vr) struct vn_reference_hasher { - typedef vn_reference_s value_type; - typedef vn_reference_s compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); - static inline void remove (value_type *); + typedef vn_reference_s *value_type; + typedef vn_reference_s *compare_type; + static inline hashval_t hash (const vn_reference_s *); + static inline bool equal (const vn_reference_s *, const vn_reference_s *); + static inline void remove (vn_reference_s *); }; /* Return the hashcode for a given reference operation P1. */ inline hashval_t -vn_reference_hasher::hash (const value_type *vr1) +vn_reference_hasher::hash (const vn_reference_s *vr1) { return vr1->hashcode; } inline bool -vn_reference_hasher::equal (const value_type *v, const compare_type *c) +vn_reference_hasher::equal (const vn_reference_s *v, const vn_reference_s *c) { return vn_reference_eq (v, c); } inline void -vn_reference_hasher::remove (value_type *v) +vn_reference_hasher::remove (vn_reference_s *v) { free_reference (v); } @@ -298,16 +298,16 @@ typedef struct vn_tables_s struct vn_constant_hasher : typed_free_remove <vn_constant_s> { - typedef vn_constant_s value_type; - typedef vn_constant_s compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef vn_constant_s *value_type; + typedef vn_constant_s *compare_type; + static inline hashval_t hash (const vn_constant_s *); + static inline bool equal (const vn_constant_s *, const vn_constant_s *); }; /* Hash table hash function for vn_constant_t. */ inline hashval_t -vn_constant_hasher::hash (const value_type *vc1) +vn_constant_hasher::hash (const vn_constant_s *vc1) { return vc1->hashcode; } @@ -315,7 +315,7 @@ vn_constant_hasher::hash (const value_type *vc1) /* Hash table equality function for vn_constant_t. */ inline bool -vn_constant_hasher::equal (const value_type *vc1, const compare_type *vc2) +vn_constant_hasher::equal (const vn_constant_s *vc1, const vn_constant_s *vc2) { if (vc1->hashcode != vc2->hashcode) return false; diff --git a/gcc/tree-ssa-structalias.c b/gcc/tree-ssa-structalias.c index fd0f535..d6a9f67 100644 --- a/gcc/tree-ssa-structalias.c +++ b/gcc/tree-ssa-structalias.c @@ -1940,16 +1940,17 @@ typedef const struct equiv_class_label *const_equiv_class_label_t; struct equiv_class_hasher : typed_free_remove <equiv_class_label> { - typedef equiv_class_label value_type; - typedef equiv_class_label compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef equiv_class_label *value_type; + typedef equiv_class_label *compare_type; + static inline hashval_t hash (const equiv_class_label *); + static inline bool equal (const equiv_class_label *, + const equiv_class_label *); }; /* Hash function for a equiv_class_label_t */ inline hashval_t -equiv_class_hasher::hash (const value_type *ecl) +equiv_class_hasher::hash (const equiv_class_label *ecl) { return ecl->hashcode; } @@ -1957,7 +1958,8 @@ equiv_class_hasher::hash (const value_type *ecl) /* Equality function for two equiv_class_label_t's. */ inline bool -equiv_class_hasher::equal (const value_type *eql1, const compare_type *eql2) +equiv_class_hasher::equal (const equiv_class_label *eql1, + const equiv_class_label *eql2) { return (eql1->hashcode == eql2->hashcode && bitmap_equal_p (eql1->labels, eql2->labels)); @@ -5963,16 +5965,17 @@ typedef const struct shared_bitmap_info *const_shared_bitmap_info_t; struct shared_bitmap_hasher : typed_free_remove <shared_bitmap_info> { - typedef shared_bitmap_info value_type; - typedef shared_bitmap_info compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef shared_bitmap_info *value_type; + typedef shared_bitmap_info *compare_type; + static inline hashval_t hash (const shared_bitmap_info *); + static inline bool equal (const shared_bitmap_info *, + const shared_bitmap_info *); }; /* Hash function for a shared_bitmap_info_t */ inline hashval_t -shared_bitmap_hasher::hash (const value_type *bi) +shared_bitmap_hasher::hash (const shared_bitmap_info *bi) { return bi->hashcode; } @@ -5980,7 +5983,8 @@ shared_bitmap_hasher::hash (const value_type *bi) /* Equality function for two shared_bitmap_info_t's. */ inline bool -shared_bitmap_hasher::equal (const value_type *sbi1, const compare_type *sbi2) +shared_bitmap_hasher::equal (const shared_bitmap_info *sbi1, + const shared_bitmap_info *sbi2) { return bitmap_equal_p (sbi1->pt_vars, sbi2->pt_vars); } diff --git a/gcc/tree-ssa-tail-merge.c b/gcc/tree-ssa-tail-merge.c index 2c48cb6..4afe94e 100644 --- a/gcc/tree-ssa-tail-merge.c +++ b/gcc/tree-ssa-tail-merge.c @@ -260,11 +260,11 @@ struct same_succ_def hashval_t hashval; /* hash_table support. */ - typedef same_succ_def value_type; - typedef same_succ_def compare_type; - static inline hashval_t hash (const value_type *); - static int equal (const value_type *, const compare_type *); - static void remove (value_type *); + typedef same_succ_def *value_type; + typedef same_succ_def *compare_type; + static inline hashval_t hash (const same_succ_def *); + static int equal (const same_succ_def *, const same_succ_def *); + static void remove (same_succ_def *); }; typedef struct same_succ_def *same_succ; typedef const struct same_succ_def *const_same_succ; @@ -272,7 +272,7 @@ typedef const struct same_succ_def *const_same_succ; /* hash routine for hash_table support, returns hashval of E. */ inline hashval_t -same_succ_def::hash (const value_type *e) +same_succ_def::hash (const same_succ_def *e) { return e->hashval; } @@ -568,7 +568,7 @@ inverse_flags (const_same_succ e1, const_same_succ e2) /* Compares SAME_SUCCs E1 and E2. */ int -same_succ_def::equal (const value_type *e1, const compare_type *e2) +same_succ_def::equal (const same_succ_def *e1, const same_succ_def *e2) { unsigned int i, first1, first2; gimple_stmt_iterator gsi1, gsi2; diff --git a/gcc/tree-ssa-threadupdate.c b/gcc/tree-ssa-threadupdate.c index 610e807..709b16e 100644 --- a/gcc/tree-ssa-threadupdate.c +++ b/gcc/tree-ssa-threadupdate.c @@ -160,10 +160,10 @@ struct redirection_data : typed_free_remove<redirection_data> struct el *incoming_edges; /* hash_table support. */ - typedef redirection_data value_type; - typedef redirection_data compare_type; - static inline hashval_t hash (const value_type *); - static inline int equal (const value_type *, const compare_type *); + typedef redirection_data *value_type; + typedef redirection_data *compare_type; + static inline hashval_t hash (const redirection_data *); + static inline int equal (const redirection_data *, const redirection_data *); }; /* Dump a jump threading path, including annotations about each @@ -209,7 +209,7 @@ dump_jump_thread_path (FILE *dump_file, vec<jump_thread_edge *> path, path. So hash on the block index of the final edge in the path. */ inline hashval_t -redirection_data::hash (const value_type *p) +redirection_data::hash (const redirection_data *p) { vec<jump_thread_edge *> *path = p->path; return path->last ()->e->dest->index; @@ -218,7 +218,7 @@ redirection_data::hash (const value_type *p) /* Given two hash table entries, return true if they have the same jump threading path. */ inline int -redirection_data::equal (const value_type *p1, const compare_type *p2) +redirection_data::equal (const redirection_data *p1, const redirection_data *p2) { vec<jump_thread_edge *> *path1 = p1->path; vec<jump_thread_edge *> *path2 = p2->path; diff --git a/gcc/tree-vectorizer.c b/gcc/tree-vectorizer.c index 415bffa..313e936 100644 --- a/gcc/tree-vectorizer.c +++ b/gcc/tree-vectorizer.c @@ -118,20 +118,20 @@ struct simduid_to_vf : typed_free_remove<simduid_to_vf> int vf; /* hash_table support. */ - typedef simduid_to_vf value_type; - typedef simduid_to_vf compare_type; - static inline hashval_t hash (const value_type *); - static inline int equal (const value_type *, const compare_type *); + typedef simduid_to_vf *value_type; + typedef simduid_to_vf *compare_type; + static inline hashval_t hash (const simduid_to_vf *); + static inline int equal (const simduid_to_vf *, const simduid_to_vf *); }; inline hashval_t -simduid_to_vf::hash (const value_type *p) +simduid_to_vf::hash (const simduid_to_vf *p) { return p->simduid; } inline int -simduid_to_vf::equal (const value_type *p1, const value_type *p2) +simduid_to_vf::equal (const simduid_to_vf *p1, const simduid_to_vf *p2) { return p1->simduid == p2->simduid; } @@ -154,20 +154,22 @@ struct simd_array_to_simduid : typed_free_remove<simd_array_to_simduid> unsigned int simduid; /* hash_table support. */ - typedef simd_array_to_simduid value_type; - typedef simd_array_to_simduid compare_type; - static inline hashval_t hash (const value_type *); - static inline int equal (const value_type *, const compare_type *); + typedef simd_array_to_simduid *value_type; + typedef simd_array_to_simduid *compare_type; + static inline hashval_t hash (const simd_array_to_simduid *); + static inline int equal (const simd_array_to_simduid *, + const simd_array_to_simduid *); }; inline hashval_t -simd_array_to_simduid::hash (const value_type *p) +simd_array_to_simduid::hash (const simd_array_to_simduid *p) { return DECL_UID (p->decl); } inline int -simd_array_to_simduid::equal (const value_type *p1, const value_type *p2) +simd_array_to_simduid::equal (const simd_array_to_simduid *p1, + const simd_array_to_simduid *p2) { return p1->decl == p2->decl; } diff --git a/gcc/tree-vectorizer.h b/gcc/tree-vectorizer.h index 66d592d..f22d6cf 100644 --- a/gcc/tree-vectorizer.h +++ b/gcc/tree-vectorizer.h @@ -220,20 +220,20 @@ typedef struct _vect_peel_extended_info struct peel_info_hasher : typed_free_remove <_vect_peel_info> { - typedef _vect_peel_info value_type; - typedef _vect_peel_info compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef _vect_peel_info *value_type; + typedef _vect_peel_info *compare_type; + static inline hashval_t hash (const _vect_peel_info *); + static inline bool equal (const _vect_peel_info *, const _vect_peel_info *); }; inline hashval_t -peel_info_hasher::hash (const value_type *peel_info) +peel_info_hasher::hash (const _vect_peel_info *peel_info) { return (hashval_t) peel_info->npeel; } inline bool -peel_info_hasher::equal (const value_type *a, const compare_type *b) +peel_info_hasher::equal (const _vect_peel_info *a, const _vect_peel_info *b) { return (a->npeel == b->npeel); } diff --git a/gcc/valtrack.h b/gcc/valtrack.h index 402fef9..b7b53f3 100644 --- a/gcc/valtrack.h +++ b/gcc/valtrack.h @@ -45,33 +45,35 @@ struct dead_debug_global_entry struct dead_debug_hash_descr { /* The hash table contains pointers to entries of this type. */ - typedef struct dead_debug_global_entry value_type; - typedef struct dead_debug_global_entry compare_type; + typedef struct dead_debug_global_entry *value_type; + typedef struct dead_debug_global_entry *compare_type; /* Hash on the pseudo number. */ - static inline hashval_t hash (const value_type *my); + static inline hashval_t hash (const dead_debug_global_entry *my); /* Entries are identical if they refer to the same pseudo. */ - static inline bool equal (const value_type *my, const compare_type *other); + static inline bool equal (const dead_debug_global_entry *my, + const dead_debug_global_entry *other); /* Release entries when they're removed. */ - static inline void remove (value_type *p); + static inline void remove (dead_debug_global_entry *p); }; /* Hash on the pseudo number. */ inline hashval_t -dead_debug_hash_descr::hash (const value_type *my) +dead_debug_hash_descr::hash (const dead_debug_global_entry *my) { return REGNO (my->reg); } /* Entries are identical if they refer to the same pseudo. */ inline bool -dead_debug_hash_descr::equal (const value_type *my, const compare_type *other) +dead_debug_hash_descr::equal (const dead_debug_global_entry *my, + const dead_debug_global_entry *other) { return my->reg == other->reg; } /* Release entries when they're removed. */ inline void -dead_debug_hash_descr::remove (value_type *p) +dead_debug_hash_descr::remove (dead_debug_global_entry *p) { XDELETE (p); } diff --git a/gcc/var-tracking.c b/gcc/var-tracking.c index 18eff20..685fcc38c 100644 --- a/gcc/var-tracking.c +++ b/gcc/var-tracking.c @@ -494,18 +494,18 @@ static void variable_htab_free (void *); struct variable_hasher { - typedef variable_def value_type; - typedef void compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); - static inline void remove (value_type *); + typedef variable_def *value_type; + typedef void *compare_type; + static inline hashval_t hash (const variable_def *); + static inline bool equal (const variable_def *, const void *); + static inline void remove (variable_def *); }; /* The hash function for variable_htab, computes the hash value from the declaration of variable X. */ inline hashval_t -variable_hasher::hash (const value_type *v) +variable_hasher::hash (const variable_def *v) { return dv_htab_hash (v->dv); } @@ -513,7 +513,7 @@ variable_hasher::hash (const value_type *v) /* Compare the declaration of variable X with declaration Y. */ inline bool -variable_hasher::equal (const value_type *v, const compare_type *y) +variable_hasher::equal (const variable_def *v, const void *y) { decl_or_value dv = CONST_CAST2 (decl_or_value, const void *, y); @@ -523,7 +523,7 @@ variable_hasher::equal (const value_type *v, const compare_type *y) /* Free the element of VARIABLE_HTAB (its type is struct variable_def). */ inline void -variable_hasher::remove (value_type *var) +variable_hasher::remove (variable_def *var) { variable_htab_free (var); } diff --git a/gcc/vtable-verify.c b/gcc/vtable-verify.c index 22b7b81..8ced835 100644 --- a/gcc/vtable-verify.c +++ b/gcc/vtable-verify.c @@ -268,14 +268,15 @@ vtbl_map_node_registration_insert (struct vtbl_map_node *node, /* Hashtable functions for vtable_registration hashtables. */ inline hashval_t -registration_hasher::hash (const value_type *p) +registration_hasher::hash (const vtable_registration *p) { const struct vtable_registration *n = (const struct vtable_registration *) p; return (hashval_t) (DECL_UID (n->vtable_decl)); } inline bool -registration_hasher::equal (const value_type *p1, const compare_type *p2) +registration_hasher::equal (const vtable_registration *p1, + const vtable_registration *p2) { const struct vtable_registration *n1 = (const struct vtable_registration *) p1; @@ -292,16 +293,16 @@ registration_hasher::equal (const value_type *p1, const compare_type *p2) struct vtbl_map_hasher : typed_noop_remove <struct vtbl_map_node> { - typedef struct vtbl_map_node value_type; - typedef struct vtbl_map_node compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef struct vtbl_map_node *value_type; + typedef struct vtbl_map_node *compare_type; + static inline hashval_t hash (const vtbl_map_node *); + static inline bool equal (const vtbl_map_node *, const vtbl_map_node *); }; /* Returns a hash code for P. */ inline hashval_t -vtbl_map_hasher::hash (const value_type *p) +vtbl_map_hasher::hash (const vtbl_map_node *p) { const struct vtbl_map_node n = *((const struct vtbl_map_node *) p); return (hashval_t) IDENTIFIER_HASH_VALUE (n.class_name); @@ -310,7 +311,7 @@ vtbl_map_hasher::hash (const value_type *p) /* Returns nonzero if P1 and P2 are equal. */ inline bool -vtbl_map_hasher::equal (const value_type *p1, const compare_type *p2) +vtbl_map_hasher::equal (const vtbl_map_node *p1, const vtbl_map_node *p2) { const struct vtbl_map_node n1 = *((const struct vtbl_map_node *) p1); const struct vtbl_map_node n2 = *((const struct vtbl_map_node *) p2); diff --git a/gcc/vtable-verify.h b/gcc/vtable-verify.h index b0169ad..6fb2b60 100644 --- a/gcc/vtable-verify.h +++ b/gcc/vtable-verify.h @@ -58,10 +58,11 @@ struct vtable_registration struct registration_hasher : typed_noop_remove <struct vtable_registration> { - typedef struct vtable_registration value_type; - typedef struct vtable_registration compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + typedef struct vtable_registration *value_type; + typedef struct vtable_registration *compare_type; + static inline hashval_t hash (const vtable_registration *); + static inline bool equal (const vtable_registration *, + const vtable_registration *); }; typedef hash_table<registration_hasher> register_table_type; diff --git a/libcc1/plugin.cc b/libcc1/plugin.cc index c4caf05..74a7ec3 100644 --- a/libcc1/plugin.cc +++ b/libcc1/plugin.cc @@ -113,38 +113,38 @@ struct decl_addr_value struct decl_addr_hasher : typed_free_remove<decl_addr_value> { - typedef decl_addr_value value_type; - typedef decl_addr_value compare_type; + typedef decl_addr_value *value_type; + typedef decl_addr_value *compare_type; - static inline hashval_t hash (const value_type *); - static inline bool equal (const value_type *, const compare_type *); + static inline hashval_t hash (const decl_addr_value *); + static inline bool equal (const decl_addr_value *, const decl_addr_value *); }; inline hashval_t -decl_addr_hasher::hash (const value_type *e) +decl_addr_hasher::hash (const decl_addr_value *e) { return IDENTIFIER_HASH_VALUE (DECL_NAME (e->decl)); } inline bool -decl_addr_hasher::equal (const value_type *p1, const compare_type *p2) +decl_addr_hasher::equal (const decl_addr_value *p1, const decl_addr_value *p2) { return p1->decl == p2->decl; } -struct string_hasher : typed_noop_remove<char> +struct string_hasher : typed_noop_remove<const char> { - typedef char value_type; - typedef char compare_type; + typedef const char *value_type; + typedef const char *compare_type; - static inline hashval_t hash (const value_type *s) + static inline hashval_t hash (const char *s) { return htab_hash_string (s); } - static inline bool equal (const value_type *p1, const value_type *p2) + static inline bool equal (const char *p1, const char *p2) { return strcmp (p1, p2) == 0; } @@ -210,7 +210,7 @@ private: // Add a file name to FILE_NAMES and return the canonical copy. const char *intern_filename (const char *filename) { - char **slot = file_names.find_slot (filename, INSERT); + const char **slot = file_names.find_slot (filename, INSERT); if (*slot == NULL) { /* The file name must live as long as the line map, which
From: Trevor Saunders <tbsaunde+gcc@tbsaunde.org> Hi, Last stage 1 I introduced a second form of hash_table that stored elements of value_type in addition to the old form that stored elements of type value_type *. That lead to a fair bit of code dupplication in hash_table, but it simplified the transition by allowing it to take place one hash table at a time. Now I'm switching the rest of the hash_table users to use the new setup, and removing supporot for the old one. this was bootstrapped and regtested on x86_64-unknown-linux-gnu, and I ran make all-gcc for the following crosses to check the hash tables they use were correctly converted arm-linux-androideabi i686-apple-darwin i686-solaris2.11 i686-w64-mingw32 ia64-linux mips64-linux nvptx-elf ppc64-linux Is this ok? Trev gcc/ * hash-table.h: Remove version of hash_table that stored value_type *. * asan.c, attribs.c, bitmap.c, cfg.c, cgraph.h, config/arm/arm.c, config/i386/winnt.c, config/ia64/ia64.c, config/mips/mips.c, config/sol2.c, coverage.c, cselib.c, dse.c, dwarf2cfi.c, dwarf2out.c, except.c, gcse.c, genmatch.c, ggc-common.c, gimple-ssa-strength-reduction.c, gimplify.c, haifa-sched.c, hard-reg-set.h, hash-map.h, hash-set.h, ipa-devirt.c, ipa-icf.h, ipa-profile.c, ira-color.c, ira-costs.c, loop-invariant.c, loop-iv.c, loop-unroll.c, lto-streamer.h, plugin.c, postreload-gcse.c, reginfo.c, statistics.c, store-motion.c, trans-mem.c, tree-cfg.c, tree-eh.c, tree-hasher.h, tree-into-ssa.c, tree-parloops.c, tree-sra.c, tree-ssa-coalesce.c, tree-ssa-dom.c, tree-ssa-live.c, tree-ssa-loop-im.c, tree-ssa-loop-ivopts.c, tree-ssa-phiopt.c, tree-ssa-pre.c, tree-ssa-reassoc.c, tree-ssa-sccvn.c, tree-ssa-structalias.c, tree-ssa-tail-merge.c, tree-ssa-threadupdate.c, tree-vectorizer.c, tree-vectorizer.h, valtrack.h, var-tracking.c, vtable-verify.c, vtable-verify.h: Adjust. libcc1/ * plugin.cc: Adjust for hash_table changes. java/ * jcf-io.c: Adjust for hash_table changes. lto/ * lto.c: Adjust for hash_table changes. objc/ * objc-act.c: Adjust for hash_table changes.