+2014-11-20 Trevor Saunders <tsaunders@mozilla.com>
+
+ * config/i386/i386.c, function.c, trans-mem.c, tree-core.h,
+ tree.c, tree.h, ubsan.c, varasm.c: Use hash_table instead of htab.
+
2014-11-20 Trevor Saunders <tsaunders@mozilla.com>
* doc/gty.texi: Document the new cache gty attribute.
+2014-11-20 Trevor Saunders <tsaunders@mozilla.com>
+
+ * gcc-interface/decl.c, gcc-interface/utils.c: replace htab with
+ hash_table.
+
2014-11-20 Robert Dewar <dewar@adacore.com>
* sem_prag.adb (Analyze_Pragma, case Elaborate): Forbid pragma
/* A hash table used to cache the result of annotate_value. */
-static GTY ((if_marked ("tree_int_map_marked_p"),
- param_is (struct tree_int_map))) htab_t annotate_value_cache;
+
+struct value_annotation_hasher : ggc_cache_hasher<tree_int_map *>
+{
+ static inline hashval_t
+ hash (tree_int_map *m)
+ {
+ return htab_hash_pointer (m->base.from);
+ }
+
+ static inline bool
+ equal (tree_int_map *a, tree_int_map *b)
+ {
+ return a->base.from == b->base.from;
+ }
+
+ static void
+ handle_cache_entry (tree_int_map *&m)
+ {
+ extern void gt_ggc_mx (tree_int_map *&);
+ if (m == HTAB_EMPTY_ENTRY || m == HTAB_DELETED_ENTRY)
+ return;
+ else if (ggc_marked_p (m->base.from))
+ gt_ggc_mx (m);
+ else
+ m = static_cast<tree_int_map *> (HTAB_DELETED_ENTRY);
+ }
+};
+
+static GTY ((cache)) hash_table<value_annotation_hasher> *annotate_value_cache;
static bool allocatable_size_p (tree, bool);
static void prepend_one_attribute (struct attrib **,
struct tree_int_map *e;
in.base.from = gnu_size;
- e = (struct tree_int_map *) htab_find (annotate_value_cache, &in);
+ e = annotate_value_cache->find (&in);
if (e)
return (Node_Ref_Or_Val) e->to;
look up, so we have to search again. Allocating and inserting an
entry at that point would be an alternative, but then we'd better
discard the entry if we decided not to cache it. */
- h = (struct tree_int_map **)
- htab_find_slot (annotate_value_cache, &in, INSERT);
+ h = annotate_value_cache->find_slot (&in, INSERT);
gcc_assert (!*h);
*h = ggc_alloc<tree_int_map> ();
(*h)->base.from = gnu_size;
init_gnat_decl (void)
{
/* Initialize the cache of annotated values. */
- annotate_value_cache
- = htab_create_ggc (512, tree_int_map_hash, tree_int_map_eq, 0);
+ annotate_value_cache = hash_table<value_annotation_hasher>::create_ggc (512);
}
/* Destroy data structures of the decl.c module. */
destroy_gnat_decl (void)
{
/* Destroy the cache of annotated values. */
- htab_delete (annotate_value_cache);
+ annotate_value_cache->empty ();
annotate_value_cache = NULL;
}
/* A chain of unused BLOCK nodes. */
static GTY((deletable)) tree free_block_chain;
-static int pad_type_hash_marked_p (const void *p);
-static hashval_t pad_type_hash_hash (const void *p);
-static int pad_type_hash_eq (const void *p1, const void *p2);
-
/* A hash table of padded types. It is modelled on the generic type
hash table in tree.c, which must thus be used as a reference. */
-struct GTY(()) pad_type_hash {
+
+struct GTY((for_user)) pad_type_hash {
unsigned long hash;
tree type;
};
-static GTY ((if_marked ("pad_type_hash_marked_p"),
- param_is (struct pad_type_hash)))
- htab_t pad_type_hash_table;
+struct pad_type_hasher : ggc_cache_hasher<pad_type_hash *>
+{
+ static inline hashval_t hash (pad_type_hash *t) { return t->hash; }
+ static bool equal (pad_type_hash *a, pad_type_hash *b);
+ static void handle_cache_entry (pad_type_hash *&);
+};
+
+static GTY ((cache))
+ hash_table<pad_type_hasher> *pad_type_hash_table;
static tree merge_sizes (tree, tree, tree, bool, bool);
static tree compute_related_constant (tree, tree);
dummy_node_table = ggc_cleared_vec_alloc<tree> (max_gnat_nodes);
/* Initialize the hash table of padded types. */
- pad_type_hash_table
- = htab_create_ggc (512, pad_type_hash_hash, pad_type_hash_eq, 0);
+ pad_type_hash_table = hash_table<pad_type_hasher>::create_ggc (512);
}
/* Destroy data structures of the utils.c module. */
dummy_node_table = NULL;
/* Destroy the hash table of padded types. */
- htab_delete (pad_type_hash_table);
+ pad_type_hash_table->empty ();
pad_type_hash_table = NULL;
/* Invalidate the global renaming pointers. */
/* See if the data pointed to by the hash table slot is marked. */
-static int
-pad_type_hash_marked_p (const void *p)
-{
- const_tree const type = ((const struct pad_type_hash *) p)->type;
-
- return ggc_marked_p (type);
-}
-
-/* Return the cached hash value. */
-
-static hashval_t
-pad_type_hash_hash (const void *p)
+void
+pad_type_hasher::handle_cache_entry (pad_type_hash *&t)
{
- return ((const struct pad_type_hash *) p)->hash;
+ extern void gt_ggc_mx (pad_type_hash *&);
+ if (t == HTAB_EMPTY_ENTRY || t == HTAB_DELETED_ENTRY)
+ return;
+ else if (ggc_marked_p (t->type))
+ gt_ggc_mx (t);
+ else
+ t = static_cast<pad_type_hash *> (HTAB_DELETED_ENTRY);
}
-/* Return 1 iff the padded types are equivalent. */
+/* Return true iff the padded types are equivalent. */
-static int
-pad_type_hash_eq (const void *p1, const void *p2)
+bool
+pad_type_hasher::equal (pad_type_hash *t1, pad_type_hash *t2)
{
- const struct pad_type_hash *const t1 = (const struct pad_type_hash *) p1;
- const struct pad_type_hash *const t2 = (const struct pad_type_hash *) p2;
tree type1, type2;
if (t1->hash != t2->hash)
{
hashval_t hashcode;
struct pad_type_hash in, *h;
- void **loc;
hashcode
= iterative_hash_object (TYPE_HASH (TREE_TYPE (TYPE_FIELDS (type))), 0);
in.hash = hashcode;
in.type = type;
- h = (struct pad_type_hash *)
- htab_find_with_hash (pad_type_hash_table, &in, hashcode);
+ h = pad_type_hash_table->find_with_hash (&in, hashcode);
if (h)
return h->type;
h = ggc_alloc<pad_type_hash> ();
h->hash = hashcode;
h->type = type;
- loc = htab_find_slot_with_hash (pad_type_hash_table, h, hashcode, INSERT);
- *loc = (void *)h;
+ *pad_type_hash_table->find_slot_with_hash (h, hashcode, INSERT) = h;
return NULL_TREE;
}
to symbol DECL if BEIMPORT is true. Otherwise create or return the
unique refptr-DECL symbol corresponding to symbol DECL. */
-static GTY((if_marked ("tree_map_marked_p"), param_is (struct tree_map)))
- htab_t dllimport_map;
+struct dllimport_hasher : ggc_cache_hasher<tree_map *>
+{
+ static inline hashval_t hash (tree_map *m) { return m->hash; }
+ static inline bool
+ equal (tree_map *a, tree_map *b)
+ {
+ return a->base.from == b->base.from;
+ }
+
+ static void
+ handle_cache_entry (tree_map *&m)
+ {
+ extern void gt_ggc_mx (tree_map *&);
+ if (m == HTAB_EMPTY_ENTRY || m == HTAB_DELETED_ENTRY)
+ return;
+ else if (ggc_marked_p (m->base.from))
+ gt_ggc_mx (m);
+ else
+ m = static_cast<tree_map *> (HTAB_DELETED_ENTRY);
+ }
+};
+
+static GTY((cache)) hash_table<dllimport_hasher> *dllimport_map;
static tree
get_dllimport_decl (tree decl, bool beimport)
{
struct tree_map *h, in;
- void **loc;
const char *name;
const char *prefix;
size_t namelen, prefixlen;
rtx rtl;
if (!dllimport_map)
- dllimport_map = htab_create_ggc (512, tree_map_hash, tree_map_eq, 0);
+ dllimport_map = hash_table<dllimport_hasher>::create_ggc (512);
in.hash = htab_hash_pointer (decl);
in.base.from = decl;
- loc = htab_find_slot_with_hash (dllimport_map, &in, in.hash, INSERT);
- h = (struct tree_map *) *loc;
+ tree_map **loc = dllimport_map->find_slot_with_hash (&in, in.hash, INSERT);
+ h = *loc;
if (h)
return h->to;
+2014-11-20 Trevor Saunders <tsaunders@mozilla.com>
+
+ * cp-objcp-common.c: Use hash_table instead of htab.
+
2014-11-19 Jason Merrill <jason@redhat.com>
PR c++/56041
return DECL_EXTERN_C_P (decl);
}
-static GTY ((if_marked ("tree_decl_map_marked_p"), param_is (struct tree_decl_map)))
- htab_t shadowed_var_for_decl;
+static GTY ((cache))
+ hash_table<tree_decl_map_cache_hasher> *shadowed_var_for_decl;
/* Lookup a shadowed var for FROM, and return it if we find one. */
struct tree_decl_map *h, in;
in.base.from = from;
- h = (struct tree_decl_map *)
- htab_find_with_hash (shadowed_var_for_decl, &in, DECL_UID (from));
+ h = shadowed_var_for_decl->find_with_hash (&in, DECL_UID (from));
if (h)
return h->to;
return NULL_TREE;
decl_shadowed_for_var_insert (tree from, tree to)
{
struct tree_decl_map *h;
- void **loc;
h = ggc_alloc<tree_decl_map> ();
h->base.from = from;
h->to = to;
- loc = htab_find_slot_with_hash (shadowed_var_for_decl, h, DECL_UID (from),
- INSERT);
- *(struct tree_decl_map **) loc = h;
+ *shadowed_var_for_decl->find_slot_with_hash (h, DECL_UID (from), INSERT) = h;
}
void
init_shadowed_var_for_decl (void)
{
- shadowed_var_for_decl = htab_create_ggc (512, tree_decl_map_hash,
- tree_decl_map_eq, 0);
+ shadowed_var_for_decl
+ = hash_table<tree_decl_map_cache_hasher>::create_ggc (512);
}
/* Return true if stmt can fall through. Used by block_may_fallthru
struct function *cfun = 0;
/* These hashes record the prologue and epilogue insns. */
-static GTY((if_marked ("ggc_marked_p"), param_is (struct rtx_def)))
- htab_t prologue_insn_hash;
-static GTY((if_marked ("ggc_marked_p"), param_is (struct rtx_def)))
- htab_t epilogue_insn_hash;
+
+struct insn_cache_hasher : ggc_cache_hasher<rtx>
+{
+ static hashval_t hash (rtx x) { return htab_hash_pointer (x); }
+ static bool equal (rtx a, rtx b) { return a == b; }
+};
+
+static GTY((cache))
+ hash_table<insn_cache_hasher> *prologue_insn_hash;
+static GTY((cache))
+ hash_table<insn_cache_hasher> *epilogue_insn_hash;
\f
hash_table<used_type_hasher> *types_used_by_vars_hash = NULL;
extern tree debug_find_var_in_block_tree (tree, tree);
/* We always define `record_insns' even if it's not used so that we
can always export `prologue_epilogue_contains'. */
-static void record_insns (rtx_insn *, rtx, htab_t *) ATTRIBUTE_UNUSED;
-static bool contains (const_rtx, htab_t);
+static void record_insns (rtx_insn *, rtx, hash_table<insn_cache_hasher> **)
+ ATTRIBUTE_UNUSED;
+static bool contains (const_rtx, hash_table<insn_cache_hasher> *);
static void prepare_function_start (void);
static void do_clobber_return_reg (rtx, void *);
static void do_use_return_reg (rtx, void *);
for the first time. */
static void
-record_insns (rtx_insn *insns, rtx end, htab_t *hashp)
+record_insns (rtx_insn *insns, rtx end, hash_table<insn_cache_hasher> **hashp)
{
rtx_insn *tmp;
- htab_t hash = *hashp;
+ hash_table<insn_cache_hasher> *hash = *hashp;
if (hash == NULL)
- *hashp = hash
- = htab_create_ggc (17, htab_hash_pointer, htab_eq_pointer, NULL);
+ *hashp = hash = hash_table<insn_cache_hasher>::create_ggc (17);
for (tmp = insns; tmp != end; tmp = NEXT_INSN (tmp))
{
- void **slot = htab_find_slot (hash, tmp, INSERT);
+ rtx *slot = hash->find_slot (tmp, INSERT);
gcc_assert (*slot == NULL);
*slot = tmp;
}
void
maybe_copy_prologue_epilogue_insn (rtx insn, rtx copy)
{
- htab_t hash;
- void **slot;
+ hash_table<insn_cache_hasher> *hash;
+ rtx *slot;
hash = epilogue_insn_hash;
- if (!hash || !htab_find (hash, insn))
+ if (!hash || !hash->find (insn))
{
hash = prologue_insn_hash;
- if (!hash || !htab_find (hash, insn))
+ if (!hash || !hash->find (insn))
return;
}
- slot = htab_find_slot (hash, copy, INSERT);
+ slot = hash->find_slot (copy, INSERT);
gcc_assert (*slot == NULL);
*slot = copy;
}
we can be running after reorg, SEQUENCE rtl is possible. */
static bool
-contains (const_rtx insn, htab_t hash)
+contains (const_rtx insn, hash_table<insn_cache_hasher> *hash)
{
if (hash == NULL)
return false;
rtx_sequence *seq = as_a <rtx_sequence *> (PATTERN (insn));
int i;
for (i = seq->len () - 1; i >= 0; i--)
- if (htab_find (hash, seq->element (i)))
+ if (hash->find (seq->element (i)))
return true;
return false;
}
- return htab_find (hash, insn) != NULL;
+ return hash->find (const_cast<rtx> (insn)) != NULL;
}
int
non-null is a signal that it is non-empty. */
if (prologue_insn_hash != NULL)
{
- size_t len = htab_elements (prologue_insn_hash);
+ size_t len = prologue_insn_hash->elements ();
rtx_insn *insn, *last = NULL, *note = NULL;
/* Scan from the beginning until we reach the last prologue insn. */
/* Map for aribtrary function replacement under TM, as created
by the tm_wrap attribute. */
-static GTY((if_marked ("tree_map_marked_p"), param_is (struct tree_map)))
- htab_t tm_wrap_map;
+struct tm_wrapper_hasher : ggc_cache_hasher<tree_map *>
+{
+ static inline hashval_t hash (tree_map *m) { return m->hash; }
+ static inline bool
+ equal (tree_map *a, tree_map *b)
+ {
+ return a->base.from == b->base.from;
+ }
+
+ static void
+ handle_cache_entry (tree_map *&m)
+ {
+ extern void gt_ggc_mx (tree_map *&);
+ if (m == HTAB_EMPTY_ENTRY || m == HTAB_DELETED_ENTRY)
+ return;
+ else if (ggc_marked_p (m->base.from))
+ gt_ggc_mx (m);
+ else
+ m = static_cast<tree_map *> (HTAB_DELETED_ENTRY);
+ }
+};
+
+static GTY((cache)) hash_table<tm_wrapper_hasher> *tm_wrap_map;
void
record_tm_replacement (tree from, tree to)
DECL_UNINLINABLE (from) = 1;
if (tm_wrap_map == NULL)
- tm_wrap_map = htab_create_ggc (32, tree_map_hash, tree_map_eq, 0);
+ tm_wrap_map = hash_table<tm_wrapper_hasher>::create_ggc (32);
h = ggc_alloc<tree_map> ();
h->hash = htab_hash_pointer (from);
h->base.from = from;
h->to = to;
- slot = (struct tree_map **)
- htab_find_slot_with_hash (tm_wrap_map, h, h->hash, INSERT);
+ slot = tm_wrap_map->find_slot_with_hash (h, h->hash, INSERT);
*slot = h;
}
in.base.from = fndecl;
in.hash = htab_hash_pointer (fndecl);
- h = (struct tree_map *) htab_find_with_hash (tm_wrap_map, &in, in.hash);
+ h = tm_wrap_map->find_with_hash (&in, in.hash);
if (h)
return h->to;
}
/* Map from a tree to another tree. */
-struct GTY(()) tree_map {
+struct GTY((for_user)) tree_map {
struct tree_map_base base;
unsigned int hash;
tree to;
};
/* Map from a decl tree to another tree. */
-struct GTY(()) tree_decl_map {
+struct GTY((for_user)) tree_decl_map {
struct tree_map_base base;
tree to;
};
/* Map from a tree to an int. */
-struct GTY(()) tree_int_map {
+struct GTY((for_user)) tree_int_map {
struct tree_map_base base;
unsigned int to;
};
/* Map from a decl tree to a tree vector. */
-struct GTY(()) tree_vec_map {
+struct GTY((for_user)) tree_vec_map {
struct tree_map_base base;
vec<tree, va_gc> *to;
};
/* Since we cannot rehash a type after it is in the table, we have to
keep the hash code. */
-struct GTY(()) type_hash {
+struct GTY((for_user)) type_hash {
unsigned long hash;
tree type;
};
/* Initial size of the hash table (rounded to next prime). */
#define TYPE_HASH_INITIAL_SIZE 1000
+struct type_cache_hasher : ggc_cache_hasher<type_hash *>
+{
+ static hashval_t hash (type_hash *t) { return t->hash; }
+ static bool equal (type_hash *a, type_hash *b);
+
+ static void
+ handle_cache_entry (type_hash *&t)
+ {
+ extern void gt_ggc_mx (type_hash *&);
+ if (t == HTAB_DELETED_ENTRY || t == HTAB_EMPTY_ENTRY)
+ return;
+ else if (ggc_marked_p (t->type))
+ gt_ggc_mx (t);
+ else
+ t = static_cast<type_hash *> (HTAB_DELETED_ENTRY);
+ }
+};
+
/* Now here is the hash table. When recording a type, it is added to
the slot whose index is the hash code. Note that the hash table is
used for several kinds of types (function types, array types and
same table, they are completely independent, and the hash code is
computed differently for each of these. */
-static GTY ((if_marked ("type_hash_marked_p"), param_is (struct type_hash)))
- htab_t type_hash_table;
+static GTY ((cache)) hash_table<type_cache_hasher> *type_hash_table;
/* Hash table and temporary node for larger integer const values. */
static GTY (()) tree int_cst_node;
/* General tree->tree mapping structure for use in hash tables. */
-static GTY ((if_marked ("tree_decl_map_marked_p"), param_is (struct tree_decl_map)))
- htab_t debug_expr_for_decl;
+static GTY ((cache))
+ hash_table<tree_decl_map_cache_hasher> *debug_expr_for_decl;
-static GTY ((if_marked ("tree_decl_map_marked_p"), param_is (struct tree_decl_map)))
- htab_t value_expr_for_decl;
+static GTY ((cache))
+ hash_table<tree_decl_map_cache_hasher> *value_expr_for_decl;
+
+ struct tree_vec_map_cache_hasher : ggc_cache_hasher<tree_vec_map *>
+{
+ static hashval_t hash (tree_vec_map *m) { return DECL_UID (m->base.from); }
+
+ static bool
+ equal (tree_vec_map *a, tree_vec_map *b)
+ {
+ return a->base.from == b->base.from;
+ }
+
+ static void
+ handle_cache_entry (tree_vec_map *&m)
+ {
+ extern void gt_ggc_mx (tree_vec_map *&);
+ if (m == HTAB_EMPTY_ENTRY || m == HTAB_DELETED_ENTRY)
+ return;
+ else if (ggc_marked_p (m->base.from))
+ gt_ggc_mx (m);
+ else
+ m = static_cast<tree_vec_map *> (HTAB_DELETED_ENTRY);
+ }
+};
-static GTY ((if_marked ("tree_vec_map_marked_p"), param_is (struct tree_vec_map)))
- htab_t debug_args_for_decl;
+static GTY ((cache))
+ hash_table<tree_vec_map_cache_hasher> *debug_args_for_decl;
static void set_type_quals (tree, int);
-static int type_hash_eq (const void *, const void *);
-static hashval_t type_hash_hash (const void *);
static void print_type_hash_statistics (void);
static void print_debug_expr_statistics (void);
static void print_value_expr_statistics (void);
-static int type_hash_marked_p (const void *);
static void type_hash_list (const_tree, inchash::hash &);
static void attribute_hash_list (const_tree, inchash::hash &);
init_ttree (void)
{
/* Initialize the hash table of types. */
- type_hash_table = htab_create_ggc (TYPE_HASH_INITIAL_SIZE, type_hash_hash,
- type_hash_eq, 0);
+ type_hash_table
+ = hash_table<type_cache_hasher>::create_ggc (TYPE_HASH_INITIAL_SIZE);
- debug_expr_for_decl = htab_create_ggc (512, tree_decl_map_hash,
- tree_decl_map_eq, 0);
+ debug_expr_for_decl
+ = hash_table<tree_decl_map_cache_hasher>::create_ggc (512);
- value_expr_for_decl = htab_create_ggc (512, tree_decl_map_hash,
- tree_decl_map_eq, 0);
+ value_expr_for_decl
+ = hash_table<tree_decl_map_cache_hasher>::create_ggc (512);
int_cst_hash_table = hash_table<int_cst_hasher>::create_ggc (1024);
print_debug_expr_statistics (void)
{
fprintf (stderr, "DECL_DEBUG_EXPR hash: size %ld, %ld elements, %f collisions\n",
- (long) htab_size (debug_expr_for_decl),
- (long) htab_elements (debug_expr_for_decl),
- htab_collisions (debug_expr_for_decl));
+ (long) debug_expr_for_decl->size (),
+ (long) debug_expr_for_decl->elements (),
+ debug_expr_for_decl->collisions ());
}
/* Print out the statistics for the DECL_VALUE_EXPR hash table. */
print_value_expr_statistics (void)
{
fprintf (stderr, "DECL_VALUE_EXPR hash: size %ld, %ld elements, %f collisions\n",
- (long) htab_size (value_expr_for_decl),
- (long) htab_elements (value_expr_for_decl),
- htab_collisions (value_expr_for_decl));
+ (long) value_expr_for_decl->size (),
+ (long) value_expr_for_decl->elements (),
+ value_expr_for_decl->collisions ());
}
/* Lookup a debug expression for FROM, and return it if we find one. */
struct tree_decl_map *h, in;
in.base.from = from;
- h = (struct tree_decl_map *)
- htab_find_with_hash (debug_expr_for_decl, &in, DECL_UID (from));
+ h = debug_expr_for_decl->find_with_hash (&in, DECL_UID (from));
if (h)
return h->to;
return NULL_TREE;
decl_debug_expr_insert (tree from, tree to)
{
struct tree_decl_map *h;
- void **loc;
h = ggc_alloc<tree_decl_map> ();
h->base.from = from;
h->to = to;
- loc = htab_find_slot_with_hash (debug_expr_for_decl, h, DECL_UID (from),
- INSERT);
- *(struct tree_decl_map **) loc = h;
+ *debug_expr_for_decl->find_slot_with_hash (h, DECL_UID (from), INSERT) = h;
}
/* Lookup a value expression for FROM, and return it if we find one. */
struct tree_decl_map *h, in;
in.base.from = from;
- h = (struct tree_decl_map *)
- htab_find_with_hash (value_expr_for_decl, &in, DECL_UID (from));
+ h = value_expr_for_decl->find_with_hash (&in, DECL_UID (from));
if (h)
return h->to;
return NULL_TREE;
decl_value_expr_insert (tree from, tree to)
{
struct tree_decl_map *h;
- void **loc;
h = ggc_alloc<tree_decl_map> ();
h->base.from = from;
h->to = to;
- loc = htab_find_slot_with_hash (value_expr_for_decl, h, DECL_UID (from),
- INSERT);
- *(struct tree_decl_map **) loc = h;
+ *value_expr_for_decl->find_slot_with_hash (h, DECL_UID (from), INSERT) = h;
}
/* Lookup a vector of debug arguments for FROM, and return it if we
return NULL;
gcc_checking_assert (debug_args_for_decl != NULL);
in.base.from = from;
- h = (struct tree_vec_map *)
- htab_find_with_hash (debug_args_for_decl, &in, DECL_UID (from));
+ h = debug_args_for_decl->find_with_hash (&in, DECL_UID (from));
if (h)
return &h->to;
return NULL;
decl_debug_args_insert (tree from)
{
struct tree_vec_map *h;
- void **loc;
+ tree_vec_map **loc;
if (DECL_HAS_DEBUG_ARGS_P (from))
return decl_debug_args_lookup (from);
if (debug_args_for_decl == NULL)
- debug_args_for_decl = htab_create_ggc (64, tree_vec_map_hash,
- tree_vec_map_eq, 0);
+ debug_args_for_decl = hash_table<tree_vec_map_cache_hasher>::create_ggc (64);
h = ggc_alloc<tree_vec_map> ();
h->base.from = from;
h->to = NULL;
- loc = htab_find_slot_with_hash (debug_args_for_decl, h, DECL_UID (from),
- INSERT);
- *(struct tree_vec_map **) loc = h;
+ loc = debug_args_for_decl->find_slot_with_hash (h, DECL_UID (from), INSERT);
+ *loc = h;
DECL_HAS_DEBUG_ARGS_P (from) = 1;
return &h->to;
}
/* Returns true iff the types are equivalent. */
-static int
-type_hash_eq (const void *va, const void *vb)
+bool
+type_cache_hasher::equal (type_hash *a, type_hash *b)
{
- const struct type_hash *const a = (const struct type_hash *) va,
- *const b = (const struct type_hash *) vb;
-
/* First test the things that are the same for all types. */
if (a->hash != b->hash
|| TREE_CODE (a->type) != TREE_CODE (b->type)
return 1;
}
-/* Return the cached hash value. */
-
-static hashval_t
-type_hash_hash (const void *item)
-{
- return ((const struct type_hash *) item)->hash;
-}
-
/* Given TYPE, and HASHCODE its hash code, return the canonical
object for an identical type if one already exists.
Otherwise, return TYPE, and record it as the canonical object.
type_hash_canon (unsigned int hashcode, tree type)
{
type_hash in;
- void **loc;
+ type_hash **loc;
/* The hash table only contains main variants, so ensure that's what we're
being passed. */
in.hash = hashcode;
in.type = type;
- loc = htab_find_slot_with_hash (type_hash_table, &in, hashcode, INSERT);
+ loc = type_hash_table->find_slot_with_hash (&in, hashcode, INSERT);
if (*loc)
{
tree t1 = ((type_hash *) *loc)->type;
h = ggc_alloc<type_hash> ();
h->hash = hashcode;
h->type = type;
- *loc = (void *)h;
+ *loc = h;
return type;
}
}
-/* See if the data pointed to by the type hash table is marked. We consider
- it marked if the type is marked or if a debug type number or symbol
- table entry has been made for the type. */
-
-static int
-type_hash_marked_p (const void *p)
-{
- const_tree const type = ((const struct type_hash *) p)->type;
-
- return ggc_marked_p (type);
-}
-
static void
print_type_hash_statistics (void)
{
fprintf (stderr, "Type hash: size %ld, %ld elements, %f collisions\n",
- (long) htab_size (type_hash_table),
- (long) htab_elements (type_hash_table),
- htab_collisions (type_hash_table));
+ (long) type_hash_table->size (),
+ (long) type_hash_table->elements (),
+ type_hash_table->collisions ());
}
/* Compute a hash code for a list of attributes (chain of TREE_LIST nodes
extern unsigned int tree_decl_map_hash (const void *);
#define tree_decl_map_marked_p tree_map_base_marked_p
+struct tree_decl_map_cache_hasher : ggc_cache_hasher<tree_decl_map *>
+{
+ static hashval_t hash (tree_decl_map *m) { return tree_decl_map_hash (m); }
+ static bool
+ equal (tree_decl_map *a, tree_decl_map *b)
+ {
+ return tree_decl_map_eq (a, b);
+ }
+
+ static void
+ handle_cache_entry (tree_decl_map *&m)
+ {
+ extern void gt_ggc_mx (tree_decl_map *&);
+ if (m == HTAB_EMPTY_ENTRY || m == HTAB_DELETED_ENTRY)
+ return;
+ else if (ggc_marked_p (m->base.from))
+ gt_ggc_mx (m);
+ else
+ m = static_cast<tree_decl_map *> (HTAB_DELETED_ENTRY);
+ }
+};
+
#define tree_int_map_eq tree_map_base_eq
#define tree_int_map_hash tree_map_base_hash
#define tree_int_map_marked_p tree_map_base_marked_p
/* Map from a tree to a VAR_DECL tree. */
-struct GTY(()) tree_type_map {
+struct GTY((for_user)) tree_type_map {
struct tree_map_base type;
tree decl;
};
-#define tree_type_map_eq tree_map_base_eq
-#define tree_type_map_marked_p tree_map_base_marked_p
-
-/* Hash from a tree in a tree_type_map. */
-
-unsigned int
-tree_type_map_hash (const void *item)
+struct tree_type_map_cache_hasher : ggc_cache_hasher<tree_type_map *>
{
- return TYPE_UID (((const struct tree_type_map *)item)->type.from);
-}
+ static inline hashval_t
+ hash (tree_type_map *t)
+ {
+ return TYPE_UID (t->type.from);
+ }
+
+ static inline bool
+ equal (tree_type_map *a, tree_type_map *b)
+ {
+ return a->type.from == b->type.from;
+ }
+
+ static void
+ handle_cache_entry (tree_type_map *&m)
+ {
+ extern void gt_ggc_mx (tree_type_map *&);
+ if (m == HTAB_EMPTY_ENTRY || m == HTAB_DELETED_ENTRY)
+ return;
+ else if (ggc_marked_p (m->type.from))
+ gt_ggc_mx (m);
+ else
+ m = static_cast<tree_type_map *> (HTAB_DELETED_ENTRY);
+ }
+};
-static GTY ((if_marked ("tree_type_map_marked_p"), param_is (struct tree_type_map)))
- htab_t decl_tree_for_type;
+static GTY ((cache))
+ hash_table<tree_type_map_cache_hasher> *decl_tree_for_type;
/* Lookup a VAR_DECL for TYPE, and return it if we find one. */
/* If the hash table is not initialized yet, create it now. */
if (decl_tree_for_type == NULL)
{
- decl_tree_for_type = htab_create_ggc (10, tree_type_map_hash,
- tree_type_map_eq, 0);
+ decl_tree_for_type
+ = hash_table<tree_type_map_cache_hasher>::create_ggc (10);
/* That also means we don't have to bother with the lookup. */
return NULL_TREE;
}
struct tree_type_map *h, in;
in.type.from = type;
- h = (struct tree_type_map *)
- htab_find_with_hash (decl_tree_for_type, &in, TYPE_UID (type));
+ h = decl_tree_for_type->find_with_hash (&in, TYPE_UID (type));
return h ? h->decl : NULL_TREE;
}
decl_for_type_insert (tree type, tree decl)
{
struct tree_type_map *h;
- void **slot;
h = ggc_alloc<tree_type_map> ();
h->type.from = type;
h->decl = decl;
- slot = htab_find_slot_with_hash (decl_tree_for_type, h, TYPE_UID (type),
- INSERT);
- *(struct tree_type_map **) slot = h;
+ *decl_tree_for_type->find_slot_with_hash (h, TYPE_UID (type), INSERT) = h;
}
/* Helper routine, which encodes a value in the pointer_sized_int_node.
to its transaction aware clone. Note that tm_pure functions are
considered to be their own clone. */
-static GTY((if_marked ("tree_map_marked_p"), param_is (struct tree_map)))
- htab_t tm_clone_hash;
+struct tm_clone_hasher : ggc_cache_hasher<tree_map *>
+{
+ static hashval_t hash (tree_map *m) { return tree_map_hash (m); }
+ static bool equal (tree_map *a, tree_map *b) { return tree_map_eq (a, b); }
+
+ static void handle_cache_entry (tree_map *&e)
+ {
+ if (e != HTAB_EMPTY_ENTRY || e != HTAB_DELETED_ENTRY)
+ {
+ extern void gt_ggc_mx (tree_map *&);
+ if (ggc_marked_p (e->base.from))
+ gt_ggc_mx (e);
+ else
+ e = static_cast<tree_map *> (HTAB_DELETED_ENTRY);
+ }
+ }
+};
+
+static GTY((cache))
+ hash_table<tm_clone_hasher> *tm_clone_hash;
void
record_tm_clone_pair (tree o, tree n)
struct tree_map **slot, *h;
if (tm_clone_hash == NULL)
- tm_clone_hash = htab_create_ggc (32, tree_map_hash, tree_map_eq, 0);
+ tm_clone_hash = hash_table<tm_clone_hasher>::create_ggc (32);
h = ggc_alloc<tree_map> ();
h->hash = htab_hash_pointer (o);
h->base.from = o;
h->to = n;
- slot = (struct tree_map **)
- htab_find_slot_with_hash (tm_clone_hash, h, h->hash, INSERT);
+ slot = tm_clone_hash->find_slot_with_hash (h, h->hash, INSERT);
*slot = h;
}
in.base.from = o;
in.hash = htab_hash_pointer (o);
- h = (struct tree_map *) htab_find_with_hash (tm_clone_hash,
- &in, in.hash);
+ h = tm_clone_hash->find_with_hash (&in, in.hash);
if (h)
return h->to;
}
} tm_alias_pair;
-/* Helper function for finish_tm_clone_pairs. Dump a hash table entry
- into a VEC in INFO. */
-
-static int
-dump_tm_clone_to_vec (void **slot, void *info)
-{
- struct tree_map *map = (struct tree_map *) *slot;
- vec<tm_alias_pair> *tm_alias_pairs = (vec<tm_alias_pair> *) info;
- tm_alias_pair p = {DECL_UID (map->base.from), map->base.from, map->to};
- tm_alias_pairs->safe_push (p);
- return 1;
-}
-
/* Dump the actual pairs to the .tm_clone_table section. */
static void
to a vector, sort it, and dump the vector. */
/* Dump the hashtable to a vector. */
- htab_traverse_noresize (tm_clone_hash, dump_tm_clone_to_vec,
- (void *) &tm_alias_pairs);
+ tree_map *map;
+ hash_table<tm_clone_hasher>::iterator iter;
+ FOR_EACH_HASH_TABLE_ELEMENT (*tm_clone_hash, map, tree_map *, iter)
+ {
+ tm_alias_pair p = {DECL_UID (map->base.from), map->base.from, map->to};
+ tm_alias_pairs.safe_push (p);
+ }
/* Sort it. */
tm_alias_pairs.qsort (tm_alias_pair_cmp);
/* Dump it. */
dump_tm_clone_pairs (tm_alias_pairs);
- htab_delete (tm_clone_hash);
+ tm_clone_hash->empty ();
tm_clone_hash = NULL;
tm_alias_pairs.release ();
}
projects / gcc.git / commitdiff