As described in the covering note, this patch replaces handle_cache_entry
with a new function keep_cache_entry. It also ensures that elements are
deleted using the proper function, so that m_n_deleted is updated.
I couldn't tell whether the unusual name of the function
("gt_cleare_cache") is deliberate or not, but I left it be.
gcc/ada/
* gcc-interface/decl.c (value_annotation_hasher::handle_cache_entry):
Delete.
(value_annotation_hasher::keep_cache_entry): New function.
* gcc-interface/utils.c (pad_type_hasher::handle_cache_entry):
Delete.
(pad_type_hasher::keep_cache_entry): New function.
gcc/
* hash-table.h (hash_table): Add gt_cleare_cache as a friend.
(gt_cleare_cache): Check here for deleted and empty entries.
Replace handle_cache_entry with a call to keep_cache_entry.
* hash-traits.h (ggc_cache_hasher::handle_cache_entry): Delete.
(ggc_cache_hasher::keep_cache_entry): New function.
* trans-mem.c (tm_wrapper_hasher::handle_cache_entry): Delete.
(tm_wrapper_hasher::keep_cache_entry): New function.
* tree.h (tree_decl_map_cache_hasher::handle_cache_entry): Delete.
(tree_vec_map_cache_hasher::keep_cache_entry): New function.
* tree.c (type_cache_hasher::handle_cache_entry): Delete.
(type_cache_hasher::keep_cache_entry): New function.
(tree_vec_map_cache_hasher::handle_cache_entry): Delete.
(tree_vec_map_cache_hasher::keep_cache_entry): New function.
* ubsan.c (tree_type_map_cache_hasher::handle_cache_entry): Delete.
(tree_type_map_cache_hasher::keep_cache_entry): New function.
* varasm.c (tm_clone_hasher::handle_cache_entry): Delete.
(tm_clone_hasher::keep_cache_entry): New function.
* config/i386/i386.c (dllimport_hasher::handle_cache_entry): Delete.
(dllimport_hasher::keep_cache_entry): New function.
Index: gcc/ada/gcc-interface/decl.c
===================================================================
--- gcc/ada/gcc-interface/decl.c 2015-06-15 16:04:47.379633614 +0100
+++ gcc/ada/gcc-interface/decl.c 2015-06-15 16:04:47.363633798 +0100
@@ -149,16 +149,10 @@ struct value_annotation_hasher : ggc_cac
return a->base.from == b->base.from;
}
- static void
- handle_cache_entry (tree_int_map *&m)
+ static int
+ keep_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);
+ return ggc_marked_p (m->base.from);
}
};
Index: gcc/ada/gcc-interface/utils.c
===================================================================
--- gcc/ada/gcc-interface/utils.c 2015-06-15 16:04:47.379633614 +0100
+++ gcc/ada/gcc-interface/utils.c 2015-06-15 16:04:47.359633844 +0100
@@ -243,7 +243,7 @@ struct pad_type_hasher : ggc_cache_hashe
{
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 int keep_cache_entry (pad_type_hash *&);
};
static GTY ((cache))
@@ -1170,16 +1170,10 @@ make_type_from_size (tree type, tree siz
/* See if the data pointed to by the hash table slot is marked. */
-void
-pad_type_hasher::handle_cache_entry (pad_type_hash *&t)
+int
+pad_type_hasher::keep_cache_entry (pad_type_hash *&t)
{
- 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 ggc_marked_p (t->type);
}
/* Return true iff the padded types are equivalent. */
Index: gcc/hash-table.h
===================================================================
--- gcc/hash-table.h 2015-06-15 16:04:47.379633614 +0100
+++ gcc/hash-table.h 2015-06-15 16:04:47.355633890 +0100
@@ -52,6 +52,16 @@ Software Foundation; either version 3, o
individual elements of the table need to be disposed of (e.g.,
when deleting a hash table, removing elements from the table, etc).
+ - An optional static function named 'keep_cache_entry'. This
+ function is provided only for garbage-collected elements that
+ are not marked by the normal gc mark pass. It describes what
+ what should happen to the element at the end of the gc mark phase.
+ The return value should be:
+ - 0 if the element should be deleted
+ - 1 if the element should be kept and needs to be marked
+ - -1 if the element should be kept and is already marked.
+ Returning -1 rather than 1 is purely an optimization.
+
3. The type of the hash table itself. (More later.)
In very special circumstances, users may need to know about a fourth type.
@@ -584,6 +594,8 @@ struct mark_empty_helper<Type *, Traits,
template<typename T> friend void gt_pch_nx (hash_table<T> *,
gt_pointer_operator, void *);
+ template<typename T> friend void gt_cleare_cache (hash_table<T> *);
+
value_type *alloc_entries (size_t n CXX_MEM_STAT_INFO) const;
value_type *find_empty_slot_for_expand (hashval_t);
void expand ();
@@ -1131,12 +1143,20 @@ gt_pch_nx (hash_table<D> *h, gt_pointer_
inline void
gt_cleare_cache (hash_table<H> *h)
{
+ extern void gt_ggc_mx (typename H::value_type &t);
+ typedef hash_table<H> table;
if (!h)
return;
- for (typename hash_table<H>::iterator iter = h->begin (); iter != h->end ();
- ++iter)
- H::handle_cache_entry (*iter);
+ for (typename table::iterator iter = h->begin (); iter != h->end (); ++iter)
+ if (!table::is_empty (*iter) && !table::is_deleted (*iter))
+ {
+ int res = H::keep_cache_entry (*iter);
+ if (res == 0)
+ h->clear_slot (&*iter);
+ else if (res != -1)
+ gt_ggc_mx (*iter);
+ }
}
#endif /* TYPED_HASHTAB_H */
Index: gcc/hash-traits.h
===================================================================
--- gcc/hash-traits.h 2015-06-15 16:04:47.379633614 +0100
+++ gcc/hash-traits.h 2015-06-15 16:04:47.355633890 +0100
@@ -146,13 +146,10 @@ struct ggc_cache_hasher
op (&p, cookie);
}
- /* Clear out entries if they are about to be gc'd. */
-
- static void
- handle_cache_entry (T &e)
+ static int
+ keep_cache_entry (T &e)
{
- if (e != HTAB_EMPTY_ENTRY && e != HTAB_DELETED_ENTRY && !ggc_marked_p (e))
- e = static_cast<T> (HTAB_DELETED_ENTRY);
+ return ggc_marked_p (e) ? -1 : 0;
}
};
Index: gcc/trans-mem.c
===================================================================
--- gcc/trans-mem.c 2015-06-15 16:04:47.379633614 +0100
+++ gcc/trans-mem.c 2015-06-15 16:04:47.359633844 +0100
@@ -483,17 +483,11 @@ struct tm_wrapper_hasher : ggc_cache_has
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 int
+ keep_cache_entry (tree_map *&m)
+ {
+ return ggc_marked_p (m->base.from);
+ }
};
static GTY((cache)) hash_table<tm_wrapper_hasher> *tm_wrap_map;
Index: gcc/tree.h
===================================================================
--- gcc/tree.h 2015-06-15 16:04:47.379633614 +0100
+++ gcc/tree.h 2015-06-15 16:04:47.375633660 +0100
@@ -4637,16 +4637,10 @@ struct tree_decl_map_cache_hasher : ggc_
return tree_decl_map_eq (a, b);
}
- static void
- handle_cache_entry (tree_decl_map *&m)
+ static int
+ keep_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);
+ return ggc_marked_p (m->base.from);
}
};
Index: gcc/tree.c
===================================================================
--- gcc/tree.c 2015-06-15 16:04:47.379633614 +0100
+++ gcc/tree.c 2015-06-15 16:04:47.375633660 +0100
@@ -203,16 +203,10 @@ struct type_cache_hasher : ggc_cache_has
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)
+ static int
+ keep_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);
+ return ggc_marked_p (t->type);
}
};
@@ -261,7 +255,7 @@ static GTY ((cache))
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 *>
+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); }
@@ -271,16 +265,10 @@ static GTY ((cache))
return a->base.from == b->base.from;
}
- static void
- handle_cache_entry (tree_vec_map *&m)
+ static int
+ keep_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);
+ return ggc_marked_p (m->base.from);
}
};
Index: gcc/ubsan.c
===================================================================
--- gcc/ubsan.c 2015-06-15 16:04:47.379633614 +0100
+++ gcc/ubsan.c 2015-06-15 16:04:47.359633844 +0100
@@ -99,16 +99,10 @@ struct tree_type_map_cache_hasher : ggc_
return a->type.from == b->type.from;
}
- static void
- handle_cache_entry (tree_type_map *&m)
+ static int
+ keep_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);
+ return ggc_marked_p (m->type.from);
}
};
Index: gcc/varasm.c
===================================================================
--- gcc/varasm.c 2015-06-15 16:04:47.379633614 +0100
+++ gcc/varasm.c 2015-06-15 16:04:47.375633660 +0100
@@ -5797,16 +5797,10 @@ struct tm_clone_hasher : ggc_cache_hashe
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)
+ static int
+ keep_cache_entry (tree_map *&e)
{
- extern void gt_ggc_mx (tree_map *&);
- if (e == HTAB_EMPTY_ENTRY || e == HTAB_DELETED_ENTRY)
- return;
- else if (ggc_marked_p (e->base.from))
- gt_ggc_mx (e);
- else
- e = static_cast<tree_map *> (HTAB_DELETED_ENTRY);
+ return ggc_marked_p (e->base.from);
}
};
Index: gcc/config/i386/i386.c
===================================================================
--- gcc/config/i386/i386.c 2015-06-15 16:04:47.379633614 +0100
+++ gcc/config/i386/i386.c 2015-06-15 16:04:47.371633705 +0100
@@ -14212,16 +14212,10 @@ struct dllimport_hasher : ggc_cache_hash
return a->base.from == b->base.from;
}
- static void
- handle_cache_entry (tree_map *&m)
+ static int
+ keep_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);
+ return ggc_marked_p (m->base.from);
}
};
