Like the previous patch, but for ggc_cache_hasher.
gcc/
* hash-traits.h (ggc_cache_hasher): Rename to...
(ggc_cache_remove): ...this and remove typedefs.
(ggc_cache_ptr_hash): New class.
* hash-table.h: Update commentary.
* emit-rtl.c (const_int_hasher): Inherit from ggc_cache_ptr_hash
rather than ggc_cache_hasher.
(const_wide_int_hasher, reg_attr_hasher): Likewise.
(const_double_hasher, const_fixed_hasher): Likewise.
* function.c (insn_cache_hasher): Likewise.
* trans-mem.c (tm_wrapper_hasher): Likewise.
* tree.h (tree_decl_map_cache_hasher): Likewise.
* tree.c (type_cache_hasher, int_cst_hasher): Likewise.
(cl_option_hasher, tree_vec_map_cache_hasher): Likewise.
* ubsan.c (tree_type_map_cache_hasher): Likewise.
* varasm.c (tm_clone_hasher): Likewise.
* config/i386/i386.c (dllimport_hasher): Likewise.
* config/nvptx/nvptx.c (declared_libfunc_hasher): Likewise.
(tree_hasher): Likewise.
gcc/ada/
* gcc-interface/decl.c (value_annotation_hasher): Inherit from
ggc_cache_ptr_hash rather than ggc_cache_hasher.
* gcc-interface/utils.c (pad_type_hasher): Likewise.
Index: gcc/hash-traits.h
===================================================================
--- gcc/hash-traits.h 2015-06-16 10:02:04.196341817 +0100
+++ gcc/hash-traits.h 2015-06-16 10:02:04.192341864 +0100
@@ -149,14 +149,12 @@ struct ggc_remove
}
};
-/* Hasher for cache entry in gc memory. */
+/* Remover and marker for "cache" entries in gc memory. These entries can
+ be deleted if there are no non-cache references to the data. */
template<typename T>
-struct ggc_cache_hasher : ggc_remove<T>
+struct ggc_cache_remove : ggc_remove<T>
{
- typedef T value_type;
- typedef T compare_type;
-
/* Entries are weakly held because this is for caches. */
static void ggc_mx (T &) {}
@@ -185,4 +183,11 @@ struct free_ptr_hash : pointer_hash <T>,
template <typename T>
struct ggc_ptr_hash : pointer_hash <T>, ggc_remove <T *> {};
+/* Traits for elements that point to gc memory. The elements don't
+ in themselves keep the pointed-to data alive and they can be deleted
+ if the pointed-to data is going to be collected. */
+
+template <typename T>
+struct ggc_cache_ptr_hash : pointer_hash <T>, ggc_cache_remove <T *> {};
+
#endif
Index: gcc/hash-table.h
===================================================================
--- gcc/hash-table.h 2015-06-16 10:02:04.196341817 +0100
+++ gcc/hash-table.h 2015-06-16 10:02:40.715918847 +0100
@@ -91,7 +91,7 @@ Software Foundation; either version 3, o
We compose this into a few steps.
1. Decide on a removal policy for values stored in the table.
- hash-traits.h provides class templates for the three most common
+ hash-traits.h provides class templates for the four most common
policies:
* typed_free_remove implements the static 'remove' member function
@@ -105,6 +105,13 @@ Software Foundation; either version 3, o
Use this for garbage-collected data that needs to be preserved across
collections.
+ * ggc_cache_remove is like ggc_remove, except that it does not
+ mark the entries during the normal gc mark phase. Instead it
+ uses 'keep_cache_entry' (described above) to keep elements that
+ were not collected and delete those that were. Use this for
+ garbage-collected caches that should not in themselves stop
+ the data from being collected.
+
You can use these policies by simply deriving the descriptor type
from one of those class template, with the appropriate argument.
Index: gcc/emit-rtl.c
===================================================================
--- gcc/emit-rtl.c 2015-06-16 10:02:04.196341817 +0100
+++ gcc/emit-rtl.c 2015-06-16 10:02:04.188341910 +0100
@@ -141,7 +141,7 @@ rtx const_tiny_rtx[4][(int) MAX_MACHINE_
/* A hash table storing CONST_INTs whose absolute value is greater
than MAX_SAVED_CONST_INT. */
-struct const_int_hasher : ggc_cache_hasher<rtx>
+struct const_int_hasher : ggc_cache_ptr_hash<rtx_def>
{
typedef HOST_WIDE_INT compare_type;
@@ -151,7 +151,7 @@ struct const_int_hasher : ggc_cache_hash
static GTY ((cache)) hash_table<const_int_hasher> *const_int_htab;
-struct const_wide_int_hasher : ggc_cache_hasher<rtx>
+struct const_wide_int_hasher : ggc_cache_ptr_hash<rtx_def>
{
static hashval_t hash (rtx x);
static bool equal (rtx x, rtx y);
@@ -160,7 +160,7 @@ struct const_wide_int_hasher : ggc_cache
static GTY ((cache)) hash_table<const_wide_int_hasher> *const_wide_int_htab;
/* A hash table storing register attribute structures. */
-struct reg_attr_hasher : ggc_cache_hasher<reg_attrs *>
+struct reg_attr_hasher : ggc_cache_ptr_hash<reg_attrs>
{
static hashval_t hash (reg_attrs *x);
static bool equal (reg_attrs *a, reg_attrs *b);
@@ -169,7 +169,7 @@ struct reg_attr_hasher : ggc_cache_hashe
static GTY ((cache)) hash_table<reg_attr_hasher> *reg_attrs_htab;
/* A hash table storing all CONST_DOUBLEs. */
-struct const_double_hasher : ggc_cache_hasher<rtx>
+struct const_double_hasher : ggc_cache_ptr_hash<rtx_def>
{
static hashval_t hash (rtx x);
static bool equal (rtx x, rtx y);
@@ -178,7 +178,7 @@ struct const_double_hasher : ggc_cache_h
static GTY ((cache)) hash_table<const_double_hasher> *const_double_htab;
/* A hash table storing all CONST_FIXEDs. */
-struct const_fixed_hasher : ggc_cache_hasher<rtx>
+struct const_fixed_hasher : ggc_cache_ptr_hash<rtx_def>
{
static hashval_t hash (rtx x);
static bool equal (rtx x, rtx y);
Index: gcc/function.c
===================================================================
--- gcc/function.c 2015-06-16 10:02:04.196341817 +0100
+++ gcc/function.c 2015-06-16 10:02:04.188341910 +0100
@@ -123,7 +123,7 @@ struct function *cfun = 0;
/* These hashes record the prologue and epilogue insns. */
-struct insn_cache_hasher : ggc_cache_hasher<rtx>
+struct insn_cache_hasher : ggc_cache_ptr_hash<rtx_def>
{
static hashval_t hash (rtx x) { return htab_hash_pointer (x); }
static bool equal (rtx a, rtx b) { return a == b; }
Index: gcc/trans-mem.c
===================================================================
--- gcc/trans-mem.c 2015-06-16 10:02:04.196341817 +0100
+++ gcc/trans-mem.c 2015-06-16 10:02:04.188341910 +0100
@@ -474,7 +474,7 @@ build_tm_abort_call (location_t loc, boo
/* Map for aribtrary function replacement under TM, as created
by the tm_wrap attribute. */
-struct tm_wrapper_hasher : ggc_cache_hasher<tree_map *>
+struct tm_wrapper_hasher : ggc_cache_ptr_hash<tree_map>
{
static inline hashval_t hash (tree_map *m) { return m->hash; }
static inline bool
Index: gcc/tree.h
===================================================================
--- gcc/tree.h 2015-06-16 10:02:04.196341817 +0100
+++ gcc/tree.h 2015-06-16 10:02:04.192341864 +0100
@@ -4628,7 +4628,7 @@ #define tree_decl_map_eq tree_map_base_e
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 *>
+struct tree_decl_map_cache_hasher : ggc_cache_ptr_hash<tree_decl_map>
{
static hashval_t hash (tree_decl_map *m) { return tree_decl_map_hash (m); }
static bool
Index: gcc/tree.c
===================================================================
--- gcc/tree.c 2015-06-16 10:02:04.196341817 +0100
+++ gcc/tree.c 2015-06-16 10:02:04.188341910 +0100
@@ -198,7 +198,7 @@ struct GTY((for_user)) type_hash {
/* 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 *>
+struct type_cache_hasher : ggc_cache_ptr_hash<type_hash>
{
static hashval_t hash (type_hash *t) { return t->hash; }
static bool equal (type_hash *a, type_hash *b);
@@ -222,7 +222,7 @@ static GTY ((cache)) hash_table<type_cac
/* Hash table and temporary node for larger integer const values. */
static GTY (()) tree int_cst_node;
-struct int_cst_hasher : ggc_cache_hasher<tree>
+struct int_cst_hasher : ggc_cache_ptr_hash<tree_node>
{
static hashval_t hash (tree t);
static bool equal (tree x, tree y);
@@ -238,7 +238,7 @@ static GTY ((cache)) hash_table<int_cst_
static GTY (()) tree cl_optimization_node;
static GTY (()) tree cl_target_option_node;
-struct cl_option_hasher : ggc_cache_hasher<tree>
+struct cl_option_hasher : ggc_cache_ptr_hash<tree_node>
{
static hashval_t hash (tree t);
static bool equal (tree x, tree y);
@@ -255,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_ptr_hash<tree_vec_map>
{
static hashval_t hash (tree_vec_map *m) { return DECL_UID (m->base.from); }
Index: gcc/ubsan.c
===================================================================
--- gcc/ubsan.c 2015-06-16 10:02:04.196341817 +0100
+++ gcc/ubsan.c 2015-06-16 10:02:04.192341864 +0100
@@ -85,7 +85,7 @@ struct GTY((for_user)) tree_type_map {
tree decl;
};
-struct tree_type_map_cache_hasher : ggc_cache_hasher<tree_type_map *>
+struct tree_type_map_cache_hasher : ggc_cache_ptr_hash<tree_type_map>
{
static inline hashval_t
hash (tree_type_map *t)
Index: gcc/varasm.c
===================================================================
--- gcc/varasm.c 2015-06-16 10:02:04.196341817 +0100
+++ gcc/varasm.c 2015-06-16 10:02:04.192341864 +0100
@@ -5792,7 +5792,7 @@ assemble_alias (tree decl, tree target)
to its transaction aware clone. Note that tm_pure functions are
considered to be their own clone. */
-struct tm_clone_hasher : ggc_cache_hasher<tree_map *>
+struct tm_clone_hasher : ggc_cache_ptr_hash<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); }
Index: gcc/config/i386/i386.c
===================================================================
--- gcc/config/i386/i386.c 2015-06-16 10:02:04.196341817 +0100
+++ gcc/config/i386/i386.c 2015-06-16 10:02:04.184341957 +0100
@@ -14203,7 +14203,7 @@ legitimize_tls_address (rtx x, enum tls_
to symbol DECL if BEIMPORT is true. Otherwise create or return the
unique refptr-DECL symbol corresponding to symbol DECL. */
-struct dllimport_hasher : ggc_cache_hasher<tree_map *>
+struct dllimport_hasher : ggc_cache_ptr_hash<tree_map>
{
static inline hashval_t hash (tree_map *m) { return m->hash; }
static inline bool
Index: gcc/config/nvptx/nvptx.c
===================================================================
--- gcc/config/nvptx/nvptx.c 2015-06-16 10:02:04.196341817 +0100
+++ gcc/config/nvptx/nvptx.c 2015-06-16 10:02:04.184341957 +0100
@@ -67,7 +67,7 @@
decls corresponding to them. */
static std::stringstream func_decls;
-struct declared_libfunc_hasher : ggc_cache_hasher<rtx>
+struct declared_libfunc_hasher : ggc_cache_ptr_hash<rtx_def>
{
static hashval_t hash (rtx x) { return htab_hash_pointer (x); }
static bool equal (rtx a, rtx b) { return a == b; }
@@ -76,7 +76,7 @@ struct declared_libfunc_hasher : ggc_cac
static GTY((cache))
hash_table<declared_libfunc_hasher> *declared_libfuncs_htab;
- struct tree_hasher : ggc_cache_hasher<tree>
+struct tree_hasher : ggc_cache_ptr_hash<tree_node>
{
static hashval_t hash (tree t) { return htab_hash_pointer (t); }
static bool equal (tree a, tree b) { return a == b; }
Index: gcc/ada/gcc-interface/decl.c
===================================================================
--- gcc/ada/gcc-interface/decl.c 2015-06-16 10:02:04.196341817 +0100
+++ gcc/ada/gcc-interface/decl.c 2015-06-16 10:02:04.172342095 +0100
@@ -135,7 +135,7 @@ typedef struct variant_desc_d {
/* A hash table used to cache the result of annotate_value. */
-struct value_annotation_hasher : ggc_cache_hasher<tree_int_map *>
+struct value_annotation_hasher : ggc_cache_ptr_hash<tree_int_map>
{
static inline hashval_t
hash (tree_int_map *m)
Index: gcc/ada/gcc-interface/utils.c
===================================================================
--- gcc/ada/gcc-interface/utils.c 2015-06-16 10:02:04.196341817 +0100
+++ gcc/ada/gcc-interface/utils.c 2015-06-16 10:02:04.176342049 +0100
@@ -239,7 +239,7 @@ struct GTY((for_user)) pad_type_hash {
tree type;
};
-struct pad_type_hasher : ggc_cache_hasher<pad_type_hash *>
+struct pad_type_hasher : ggc_cache_ptr_hash<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);
