+2015-04-18 Trevor Saunders <tsaunders@mozilla.com>
+
+ * 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.
+
2015-04-17 Bill Schmidt <wschmidt@linux.vnet.ibm.com>
PR target/65787
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. */
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]);
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;
}
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;
}
{
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);
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);
}
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);
}
/* 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);
}
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;
/* 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,
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);
}
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;
}
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;
}
\f
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);
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;
/* 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
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;
}
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;
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
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);
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);
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;
}
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;
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;
}
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;
}
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;
}
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);
}
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));
}
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));
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;
}
/* 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;
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;
}
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);
}
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
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);
}
/* 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;
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
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);
}
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);
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;
}
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);
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);
}
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);
}
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
}
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;
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);
}
/* 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);
}
/* 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;
}
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 ();
typedef hash_entry value_type;
typedef Key compare_type;
- typedef int store_values_directly;
static hashval_t hash (const hash_entry &e)
{
typedef hash_entry value_type;
typedef Key compare_type;
- typedef int store_values_directly;
static hashval_t hash (const hash_entry &e)
{
{
typedef Type *value_type;
typedef Type *compare_type;
- typedef int store_values_directly;
static inline hashval_t hash (const value_type &);
{
typedef T value_type;
typedef T compare_type;
- typedef int store_values_directly;
static void remove (T) {}
{
typedef T value_type;
typedef T compare_type;
- typedef int store_values_directly;
static void remove (T &) {}
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
{
/* 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.
*/
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;
};
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)
}
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]))
/* 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;
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;
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;
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;
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)));
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++;
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)
{
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);
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 ();
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)
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 )
{
/* 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 ();
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.
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
/* 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);
}
/* 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);
}
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;
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;
/* 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 ();
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);
/* 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
/* 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);
/* 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;
}
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
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);
}
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,
/* 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);
}
+2015-04-18 Trevor Saunders <tsaunders@mozilla.com>
+
+ * jcf-io.c: Adjust for hash_table changes.
+
2015-01-30 Joseph Myers <joseph@codesourcery.com>
* class.c, expr.c, jcf-parse.c, jvspec.c: All callers of
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;
}
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;
}
/* 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;
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;
}
/* 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);
}
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);
}
/* 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;
}
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);
}
/* 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;
}
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;
/* 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;
+2015-04-18 Trevor Saunders <tsaunders@mozilla.com>
+
+ * lto.c: Adjust for hash_table changes.
+
2015-03-27 Jan Hubicka <hubicka@ucw.cz>
* lto.c (lto_read_decls): Move code registering odr types out
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
+2015-04-18 Trevor Saunders <tsaunders@mozilla.com>
+
+ * objc-act.c: Adjust for hash_table changes.
+
2015-01-09 Michael Collison <michael.collison@linaro.org>
* objc-act.c: Include hash-set.h, machmode.h, vec.h, double-int.h,
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);
}
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);
}
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);
}
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 *);
};
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;
}
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);
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 *);
-};
\f
struct target_hard_regs default_target_hard_regs;
struct target_regs default_target_regs;
\f
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;
}
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;
}
/* 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;
}
/* 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);
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);
}
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:
/* 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);
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;
}
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
/* 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);
}
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);
}
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);
}
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;
}
{
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)
{
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 &);
};
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;
}
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;
}
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;
}
/* 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);
}
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);
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);
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
}
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);
}
{
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 &);
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);
}
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;
}
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);
}
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;
}
/* 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);
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.
/* 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);
/* 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
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;
/* 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;
/* 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)
{
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;
}
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;
{
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; }
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;
}
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);
}
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;
}
/* 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);
}
/* 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 ();
}
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);
}
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;
}
/* 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;
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;
}
/* 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));
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;
}
/* 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);
}
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;
/* 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;
}
/* 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;
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
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;
/* 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;
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;
}
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;
}
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);
}
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);
}
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);
}
/* 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);
/* 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);
}
/* 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;
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);
/* 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);
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;
+2015-04-18 Trevor Saunders <tsaunders@mozilla.com>
+
+ * plugin.cc: Adjust for hash_table changes.
+
2015-04-15 Andreas Schwab <schwab@suse.de>
PR bootstrap/65763
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;
}
\f
-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;
}
// 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
projects / gcc.git / commitdiff