This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[PATCH] Remove class cache_map and use ggc hash_maps instead (PR c++/70452)


On Mon, 4 Apr 2016, Jason Merrill wrote:

> Hmm, I thought I remembered hitting the breakpoint in gt_cleare_cache and it
> being non-null.  But I guess we can get rid of the cache_map class and use the
> approach you have here, of a deletable gc-allocated hash_map pointer; I'd
> still use ->empty() for dumping the cache outside of GC, though.

Is this what you had in mind?

gcc/cp/ChangeLog:

	PR c++/70452
	* cp-tree.h (class cache_map): Remove.
	* constexpr.c (cv_cache): Change type to
	GTY((deletable)) hash_map<tree, tree> *.
	(maybe_constant_value): Adjust following the change to cv_cache.
	(clear_cv_cache): New static function.
	(clear_cv_and_fold_caches): Use it.
	* cp-gimplify.c (fold_cache): Change type to
	GTY((deletable)) hash_map<tree, tree> *.
	(clear_fold_cache): Adjust following the change to fold_cache.
	(cp_fold): Likewise.
---
 gcc/cp/constexpr.c   | 27 ++++++++++++++++++---------
 gcc/cp/cp-gimplify.c | 17 +++++++++++------
 gcc/cp/cp-tree.h     | 36 ------------------------------------
 3 files changed, 29 insertions(+), 51 deletions(-)

diff --git a/gcc/cp/constexpr.c b/gcc/cp/constexpr.c
index bcbf9bd..8f080ee 100644
--- a/gcc/cp/constexpr.c
+++ b/gcc/cp/constexpr.c
@@ -4304,7 +4304,7 @@ maybe_constant_value_1 (tree t, tree decl)
   return r;
 }
 
-static GTY((cache, deletable)) cache_map cv_cache;
+static GTY((deletable)) hash_map<tree, tree> *cv_cache;
 
 /* If T is a constant expression, returns its reduced value.
    Otherwise, if T does not have TREE_CONSTANT set, returns T.
@@ -4313,13 +4313,22 @@ static GTY((cache, deletable)) cache_map cv_cache;
 tree
 maybe_constant_value (tree t, tree decl)
 {
-  tree ret = cv_cache.get (t);
-  if (!ret)
-    {
-      ret = maybe_constant_value_1 (t, decl);
-      cv_cache.put (t, ret);
-    }
-  return ret;
+  if (cv_cache == NULL)
+    cv_cache = hash_map<tree, tree>::create_ggc (101);
+
+  tree *slot = &cv_cache->get_or_insert (t, NULL);
+  if (*slot == NULL_TREE)
+    *slot = maybe_constant_value_1 (t, decl);
+  return *slot;
+}
+
+/* Dispose of the whole CV_CACHE.  */
+
+static void
+clear_cv_cache (void)
+{
+  if (cv_cache != NULL)
+    cv_cache->empty ();
 }
 
 /* Dispose of the whole CV_CACHE and FOLD_CACHE.  */
@@ -4327,7 +4336,7 @@ maybe_constant_value (tree t, tree decl)
 void
 clear_cv_and_fold_caches (void)
 {
-  gt_cleare_cache (cv_cache);
+  clear_cv_cache ();
   clear_fold_cache ();
 }
 
diff --git a/gcc/cp/cp-gimplify.c b/gcc/cp/cp-gimplify.c
index b6e1d27..61ac187 100644
--- a/gcc/cp/cp-gimplify.c
+++ b/gcc/cp/cp-gimplify.c
@@ -1902,14 +1902,15 @@ c_fully_fold (tree x, bool /*in_init*/, bool */*maybe_const*/)
   return cp_fold_rvalue (x);
 }
 
-static GTY((cache, deletable)) cache_map fold_cache;
+static GTY((deletable)) hash_map<tree, tree> *fold_cache;
 
 /* Dispose of the whole FOLD_CACHE.  */
 
 void
 clear_fold_cache (void)
 {
-  gt_cleare_cache (fold_cache);
+  if (fold_cache != NULL)
+    fold_cache->empty ();
 }
 
 /*  This function tries to fold an expression X.
@@ -1939,8 +1940,12 @@ cp_fold (tree x)
   if (DECL_P (x) || CONSTANT_CLASS_P (x))
     return x;
 
-  if (tree cached = fold_cache.get (x))
-    return cached;
+  if (fold_cache == NULL)
+    fold_cache = hash_map<tree, tree>::create_ggc (101);
+
+  tree *slot = &fold_cache->get_or_insert (x, NULL);
+  if (*slot != NULL_TREE)
+    return *slot;
 
   code = TREE_CODE (x);
   switch (code)
@@ -2295,10 +2300,10 @@ cp_fold (tree x)
       return org_x;
     }
 
-  fold_cache.put (org_x, x);
+  *slot = x;
   /* Prevent that we try to fold an already folded result again.  */
   if (x != org_x)
-    fold_cache.put (x, x);
+    fold_cache->put (x, x);
 
   return x;
 }
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index b1d2bfa..0f7e08f 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -5527,42 +5527,6 @@ extern cp_parameter_declarator *no_parameters;
 /* True if we saw "#pragma GCC java_exceptions".  */
 extern bool pragma_java_exceptions;
 
-/* Data structure for a mapping from tree to tree that's only used as a cache;
-   we don't GC-mark trees in the map, and we clear the map when collecting
-   garbage.  Global variables of this type must be marked
-   GTY((cache,deletable)) so that the gt_cleare_cache function is called by
-   ggc_collect but we don't try to load the map pointer from a PCH.
-
-   FIXME improve to use keep_cache_entry.  */
-class cache_map
-{
-  /* Use a lazily initialized pointer rather than a map member since a
-     hash_map can't be constructed in a static initializer.  */
-  hash_map<tree, tree> *map;
-
-public:
-  tree get (tree key)
-  {
-    if (map)
-      if (tree *slot = map->get (key))
-	return *slot;
-    return NULL_TREE;
-  }
-
-  bool put (tree key, tree val)
-  {
-    if (!map)
-      map = new hash_map<tree, tree>;
-    return map->put (key, val);
-  }
-
-  friend inline void gt_cleare_cache (cache_map &cm)
-  {
-    if (cm.map)
-      cm.map->empty();
-  }
-};
-
 /* in call.c */
 extern bool check_dtor_name			(tree, tree);
 int magic_varargs_p				(tree);
-- 
2.8.0.rc3.27.gade0865


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]