[08/13] Add a ggc_cache_ptr_hash

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);