On 11/5/20 8:30 AM, Richard Biener wrote:
On Tue, Nov 3, 2020 at 10:16 PM Nathan Sidwell <nat...@acm.org> wrote:
These are changes to gcc/tree.h adding some raw accessors to nodes,
which seemed preferable to direct field access. I also needed access to
the integral constant cache
can you please document the adjusted interface to cache_integer_cst in
its (non-existing) function level comment? It looks like 'replace'== true
turns it into get_or_insert from now put with an assertion it wasn't in the
cache.
Sure. It's a little weird in that the current behaviour is to allow
duplicates in the hash table, but not in the type's small-value vector.
I renamed the new parameter and documented what happens. I'll apply
this as a distinct patch during the merge (with changelog). For now it
lives on the modules branch
nathan
--
Nathan Sidwell
diff --git c/gcc/tree.c w/gcc/tree.c
index 9260772b846..9e10df0d7d0 100644
--- c/gcc/tree.c
+++ w/gcc/tree.c
@@ -1727,8 +1727,15 @@ wide_int_to_tree (tree type, const poly_wide_int_ref &value)
return build_poly_int_cst (type, value);
}
-void
-cache_integer_cst (tree t)
+/* Insert INTEGER_CST T into a cache of integer constants. And return
+ the cached constant (which may or may not be T). If MAY_DUPLICATE
+ is false, and T falls into the type's 'smaller values' range, there
+ cannot be an existing entry. Otherwise, if MAY_DUPLICATE is true,
+ or the value is large, should an existing entry exist, it is
+ returned (rather than inserting T). */
+
+tree
+cache_integer_cst (tree t, bool may_duplicate ATTRIBUTE_UNUSED)
{
tree type = TREE_TYPE (t);
int ix = -1;
@@ -1742,7 +1749,7 @@ cache_integer_cst (tree t)
switch (TREE_CODE (type))
{
case NULLPTR_TYPE:
- gcc_assert (integer_zerop (t));
+ gcc_checking_assert (integer_zerop (t));
/* Fallthru. */
case POINTER_TYPE:
@@ -1822,21 +1829,32 @@ cache_integer_cst (tree t)
TYPE_CACHED_VALUES (type) = make_tree_vec (limit);
}
- gcc_assert (TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) == NULL_TREE);
- TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) = t;
+ if (tree r = TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix))
+ {
+ gcc_checking_assert (may_duplicate);
+ t = r;
+ }
+ else
+ TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) = t;
}
else
{
/* Use the cache of larger shared ints. */
tree *slot = int_cst_hash_table->find_slot (t, INSERT);
- /* If there is already an entry for the number verify it's the
- same. */
- if (*slot)
- gcc_assert (wi::to_wide (tree (*slot)) == wi::to_wide (t));
+ if (tree r = *slot)
+ {
+ /* If there is already an entry for the number verify it's the
+ same value. */
+ gcc_checking_assert (wi::to_wide (tree (r)) == wi::to_wide (t));
+ /* And return the cached value. */
+ t = r;
+ }
else
/* Otherwise insert this one into the hash table. */
*slot = t;
}
+
+ return t;
}
