mirror/gcc
2
0
Fork 0
mirror of git://gcc.gnu.org/git/gcc.git synced 2025-04-10 00:01:35 +08:00
Code Issues Packages Projects Releases Wiki Activity

extend cache_integer_cst

Browse Source 
This modules-related patch extends cache_integer_cst.  Currently, when
given a small cst, that cst is added to the type's small and /must
not/ already be there.  Large values are fine if they are already in
the large cache.  This adds a parameter to indicate small duplicates
are ok, and it returns the cached value -- either what was already
tehre, or the newly inserted const.

	gcc/
	* tree.h (cache_integer_cst): Add defaulted might_duplicate parm.
	* tree.c (cache_integer_cst): Return the integer cst, add
	might_duplicate parm to permit finding a small duplicate.
This commit is contained in:
Nathan Sidwell 2020-11-17 13:23:32 -08:00
parent e0da4aed17
commit d3ae802402
2 changed files with 28 additions and 10 deletions

36
gcc/tree.c

@ -1755,8 +1755,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 MIGHT_DUPLICATE
is false, and T falls into the type's 'smaller values' range, there
cannot be an existing entry. Otherwise, if MIGHT_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 might_duplicate ATTRIBUTE_UNUSED)
{
tree type = TREE_TYPE (t);
int ix = -1;
@ -1770,7 +1777,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:
@ -1850,21 +1857,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 (might_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;
}

2
gcc/tree.h

@ -5124,7 +5124,7 @@ extern const_tree strip_invariant_refs (const_tree);
extern tree lhd_gcc_personality (void);
extern void assign_assembler_name_if_needed (tree);
extern bool warn_deprecated_use (tree, tree);
extern void cache_integer_cst (tree);
extern tree cache_integer_cst (tree, bool might_duplicate = false);
extern const char *combined_fn_name (combined_fn);
/* Compare and hash for any structure which begins with a canonical