=== modified file 'gcc/var-tracking.c'
@@ -233,17 +233,6 @@ typedef struct attrs_def
HOST_WIDE_INT offset;
} *attrs;
-/* Structure holding a refcounted hash table. If refcount > 1,
- it must be first unshared before modified. */
-typedef struct shared_hash_def
-{
- /* Reference count. */
- int refcount;
-
- /* Actual hash table. */
- htab_t htab;
-} *shared_hash;
-
/* Structure holding the IN or OUT set for a basic block. */
typedef struct dataflow_set_def
{
@@ -253,11 +242,11 @@ typedef struct dataflow_set_def
/* Attributes for registers (lists of attrs). */
attrs regs[FIRST_PSEUDO_REGISTER];
- /* Variable locations. */
- shared_hash vars;
+ /* Variable locations, stored in a hash table. */
+ htab_t vars;
/* Vars that is being traversed. */
- shared_hash traversed_vars;
+ htab_t traversed_vars;
} dataflow_set;
/* The structure (one for each basic block) containing the information
@@ -379,9 +368,6 @@ static alloc_pool valvar_pool;
/* Alloc pool for struct location_chain_def. */
static alloc_pool loc_chain_pool;
-/* Alloc pool for struct shared_hash_def. */
-static alloc_pool shared_hash_pool;
-
/* Alloc pool for struct value_chain_def. */
static alloc_pool value_chain_pool;
@@ -395,7 +381,7 @@ static htab_t value_chains;
static bool emit_notes;
/* Empty shared hashtable. */
-static shared_hash empty_shared_hash;
+static htab_t empty_htab;
/* Scratch register bitmap used by cselib_expand_value_rtx. */
static bitmap scratch_regs = NULL;
@@ -478,7 +464,7 @@ static void **delete_slot_part (dataflow
static void delete_variable_part (dataflow_set *, rtx,
decl_or_value, HOST_WIDE_INT);
static int emit_note_insn_var_location (void **, void *);
-static void emit_notes_for_changes (rtx, enum emit_note_where, shared_hash);
+static void emit_notes_for_changes (rtx, enum emit_note_where, htab_t);
static int emit_notes_for_differences_1 (void **, void *);
static int emit_notes_for_differences_2 (void **, void *);
static void emit_notes_for_differences (rtx, dataflow_set *, dataflow_set *);
@@ -1370,164 +1356,30 @@ attrs_list_mpdv_union (attrs *dstp, attr
}
}
-/* Shared hashtable support. */
-
-/* Return true if VARS is shared. */
-
-static inline bool
-shared_hash_shared (shared_hash vars)
-{
- return vars->refcount > 1;
-}
-
-/* Return the hash table for VARS. */
-
-static inline htab_t
-shared_hash_htab (shared_hash vars)
-{
- return vars->htab;
-}
-
/* Return true if VAR is shared, or maybe because VARS is shared. */
static inline bool
-shared_var_p (variable var, shared_hash vars)
+shared_var_p (variable var)
{
/* Don't count an entry in the changed_variables table as a duplicate. */
- return ((var->refcount > 1 + (int) var->in_changed_variables)
- || shared_hash_shared (vars));
+ return (var->refcount - (int) var->in_changed_variables) > 1;
}
-/* Copy all variables from hash table SRC to hash table DST without rehashing
- any values. */
-
-static htab_t
-htab_dup (htab_t src)
-{
- htab_t dst;
-
- dst = (htab_t) xmalloc (sizeof (*src));
- memcpy (dst, src, sizeof (*src));
- dst->entries = (void **) xmalloc (src->size * sizeof (*src->entries));
- memcpy (dst->entries, src->entries,
- src->size * sizeof (*src->entries));
- return dst;
-}
-
-/* Copy variables into a new hash table. */
-
-static shared_hash
-shared_hash_unshare (shared_hash vars)
-{
- variable var;
- htab_iterator hi;
- shared_hash new_vars = (shared_hash) pool_alloc (shared_hash_pool);
-
- gcc_assert (vars->refcount > 1);
- new_vars->refcount = 1;
- new_vars->htab = htab_dup (vars->htab);
- FOR_EACH_HTAB_ELEMENT (new_vars->htab, var, variable, hi)
- {
- var->refcount++;
- }
- vars->refcount--;
-
- return new_vars;
-}
-
-/* Increment reference counter on VARS and return it. */
-
-static inline shared_hash
-shared_hash_copy (shared_hash vars)
-{
- vars->refcount++;
- return vars;
-}
-
-/* Decrement reference counter and destroy hash table if not shared
- anymore. */
-
-static void
-shared_hash_destroy (shared_hash vars, bool do_free)
-{
- gcc_checking_assert (vars->refcount > 0);
- if (--vars->refcount == 0)
- {
- if (!do_free)
- /* Dirty hack to prevent htab_delete() iterating over all elements */
- vars->htab->del_f = NULL;
- htab_delete (vars->htab);
- if (do_free)
- pool_free (shared_hash_pool, vars);
- }
-}
-
-/* Unshare *PVARS if shared and return slot for DV. If INS is
- INSERT, insert it if not already present. */
+/* Search for a dv in a hash table of variables/value_chains, return its
+ slot. */
static inline void **
-shared_hash_find_slot_unshare_1 (shared_hash *pvars, decl_or_value dv,
- hashval_t dvhash, enum insert_option ins)
+htab_slot_dv (htab_t vars, decl_or_value dv, enum insert_option ins)
{
- if (shared_hash_shared (*pvars))
- *pvars = shared_hash_unshare (*pvars);
- return htab_find_slot_with_hash (shared_hash_htab (*pvars), dv, dvhash, ins);
+ return htab_find_slot_with_hash (vars, dv, dv_htab_hash (dv), ins);
}
-static inline void **
-shared_hash_find_slot_unshare (shared_hash *pvars, decl_or_value dv,
- enum insert_option ins)
-{
- return shared_hash_find_slot_unshare_1 (pvars, dv, dv_htab_hash (dv), ins);
-}
-
-/* Return slot for DV, if it is already present in the hash table.
- If it is not present, insert it only VARS is not shared, otherwise
- return NULL. */
-
-static inline void **
-shared_hash_find_slot_1 (shared_hash vars, decl_or_value dv, hashval_t dvhash)
-{
- return htab_find_slot_with_hash (shared_hash_htab (vars), dv, dvhash,
- shared_hash_shared (vars)
- ? NO_INSERT : INSERT);
-}
-
-static inline void **
-shared_hash_find_slot (shared_hash vars, decl_or_value dv)
-{
- return shared_hash_find_slot_1 (vars, dv, dv_htab_hash (dv));
-}
-
-/* Return slot for DV only if it is already present in the hash table. */
-
-static inline void **
-shared_hash_find_slot_noinsert_1 (shared_hash vars, decl_or_value dv,
- hashval_t dvhash)
-{
- return htab_find_slot_with_hash (shared_hash_htab (vars), dv, dvhash,
- NO_INSERT);
-}
-
-static inline void **
-shared_hash_find_slot_noinsert (shared_hash vars, decl_or_value dv)
-{
- return shared_hash_find_slot_noinsert_1 (vars, dv, dv_htab_hash (dv));
-}
-
-/* Return variable for DV or NULL if not already present in the hash
- table. */
+/* Search for a dv in a hash table of variables. */
static inline variable
-shared_hash_find_1 (shared_hash vars, decl_or_value dv, hashval_t dvhash)
+htab_find_dv (htab_t vars, decl_or_value dv)
{
- return (variable) htab_find_with_hash (shared_hash_htab (vars), dv, dvhash);
-}
-
-static inline variable
-shared_hash_find (shared_hash vars, decl_or_value dv)
-{
- return shared_hash_find_1 (vars, dv, dv_htab_hash (dv));
+ return (variable) htab_find_with_hash (vars, dv, dv_htab_hash (dv));
}
/* Return true if TVAL is better than CVAL as a canonival value. We
@@ -1546,8 +1398,6 @@ canon_value_cmp (rtx tval, rtx cval)
|| CSELIB_VAL_PTR (tval)->uid < CSELIB_VAL_PTR (cval)->uid;
}
-static bool dst_can_be_shared;
-
/* Return a copy of a variable VAR and insert it to dataflow set SET. */
static void **
@@ -1599,17 +1449,13 @@ unshare_variable (dataflow_set *set, voi
new_var->var_part[i].cur_loc = var->var_part[i].cur_loc;
}
- dst_can_be_shared = false;
- if (shared_hash_shared (set->vars))
- slot = shared_hash_find_slot_unshare (&set->vars, var->dv, NO_INSERT);
- else if (set->traversed_vars && set->vars != set->traversed_vars)
- slot = shared_hash_find_slot_noinsert (set->vars, var->dv);
+ if (set->traversed_vars && set->vars != set->traversed_vars)
+ slot = htab_slot_dv (set->vars, var->dv, NO_INSERT);
*slot = new_var;
if (var->in_changed_variables)
{
void **cslot
- = htab_find_slot_with_hash (changed_variables, var->dv,
- dv_htab_hash (var->dv), NO_INSERT);
+ = htab_slot_dv (changed_variables, var->dv, NO_INSERT);
gcc_assert (*cslot == (void *) var);
var->in_changed_variables = false;
variable_htab_free (var);
@@ -1680,7 +1526,7 @@ get_init_value (dataflow_set *set, rtx l
if (! flag_var_tracking_uninit)
return VAR_INIT_STATUS_INITIALIZED;
- var = shared_hash_find (set->vars, dv);
+ var = htab_find_dv (set->vars, dv);
if (var)
{
for (i = 0; i < var->n_var_parts && ret_val == VAR_INIT_STATUS_UNKNOWN; i++)
@@ -1910,7 +1756,7 @@ val_store (dataflow_set *set, rtx val, r
static void
val_reset (dataflow_set *set, decl_or_value dv)
{
- variable var = shared_hash_find (set->vars, dv) ;
+ variable var = htab_find_dv (set->vars, dv);
location_chain node;
rtx cval;
@@ -2043,7 +1889,8 @@ dataflow_set_init (dataflow_set *set)
{
/* Initialize the set (array) SET of attrs to empty lists. */
memset (set->regs, 0, sizeof (set->regs));
- set->vars = shared_hash_copy (empty_shared_hash);
+ set->vars = htab_create (5, variable_htab_hash, variable_htab_eq,
+ variable_htab_free);
set->stack_adjust = 0;
set->traversed_vars = NULL;
}
@@ -2058,8 +1905,23 @@ dataflow_set_clear (dataflow_set *set)
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
attrs_list_clear (&set->regs[i]);
- shared_hash_destroy (set->vars, true);
- set->vars = shared_hash_copy (empty_shared_hash);
+ htab_empty (set->vars);
+}
+
+/* Copy all variables from hash table SRC to hash table DST without rehashing
+ any values. */
+
+static htab_t
+htab_dup (htab_t src)
+{
+ htab_t dst;
+
+ dst = (htab_t) xmalloc (sizeof (*src));
+ memcpy (dst, src, sizeof (*src));
+ dst->entries = (void **) xmalloc (src->size * sizeof (*src->entries));
+ memcpy (dst->entries, src->entries,
+ src->size * sizeof (*src->entries));
+ return dst;
}
/* Copy the contents of dataflow set SRC to DST. */
@@ -2067,14 +1929,19 @@ dataflow_set_clear (dataflow_set *set)
static void
dataflow_set_copy (dataflow_set *dst, dataflow_set *src)
{
+ htab_iterator hi;
+ variable var;
int i;
+ /* TODO memcpy */
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
attrs_list_copy (&dst->regs[i], src->regs[i]);
- shared_hash_destroy (dst->vars, true);
- dst->vars = shared_hash_copy (src->vars);
+ htab_delete (dst->vars);
dst->stack_adjust = src->stack_adjust;
+ dst->vars = htab_dup (src->vars);
+ FOR_EACH_HTAB_ELEMENT (dst->vars, var, variable, hi)
+ var->refcount++;
}
/* Information for merging lists of locations for a given offset of variable.
@@ -2128,22 +1995,17 @@ variable_union (variable src, dataflow_s
void **dstp;
int i, j, k;
- dstp = shared_hash_find_slot (set->vars, src->dv);
- if (!dstp || !*dstp)
+ dstp = htab_slot_dv (set->vars, src->dv, INSERT);
+ if (*dstp == HTAB_EMPTY_ENTRY)
{
src->refcount++;
-
- dst_can_be_shared = false;
- if (!dstp)
- dstp = shared_hash_find_slot_unshare (&set->vars, src->dv, INSERT);
-
*dstp = src;
/* Continue traversing the hash table. */
return 1;
}
- else
- dst = (variable) *dstp;
+
+ dst = (variable) *dstp;
gcc_assert (src->n_var_parts);
@@ -2172,7 +2034,7 @@ variable_union (variable src, dataflow_s
{
location_chain nnode;
- if (shared_var_p (dst, set->vars))
+ if (shared_var_p (dst))
{
dstp = unshare_variable (set, dstp, dst,
VAR_INIT_STATUS_INITIALIZED);
@@ -2224,7 +2086,7 @@ variable_union (variable src, dataflow_s
thus there are at most MAX_VAR_PARTS different offsets. */
gcc_assert (dv_onepart_p (dst->dv) ? k == 1 : k <= MAX_VAR_PARTS);
- if (dst->n_var_parts != k && shared_var_p (dst, set->vars))
+ if (dst->n_var_parts != k && shared_var_p (dst))
{
dstp = unshare_variable (set, dstp, dst, VAR_INIT_STATUS_UNKNOWN);
dst = (variable)*dstp;
@@ -2251,7 +2113,7 @@ variable_union (variable src, dataflow_s
/* If DST is shared compare the location chains.
If they are different we will modify the chain in DST with
high probability so make a copy of DST. */
- if (shared_var_p (dst, set->vars))
+ if (shared_var_p (dst))
{
for (node = src->var_part[i].loc_chain,
node2 = dst->var_part[j].loc_chain; node && node2;
@@ -2490,24 +2352,15 @@ variable_union (variable src, dataflow_s
static void
dataflow_set_union (dataflow_set *dst, dataflow_set *src)
{
+ htab_iterator hi;
+ variable var;
int i;
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
attrs_list_union (&dst->regs[i], src->regs[i]);
- if (dst->vars == empty_shared_hash)
- {
- shared_hash_destroy (dst->vars, true);
- dst->vars = shared_hash_copy (src->vars);
- }
- else
- {
- htab_iterator hi;
- variable var;
-
- FOR_EACH_HTAB_ELEMENT (shared_hash_htab (src->vars), var, variable, hi)
- variable_union (var, dst);
- }
+ FOR_EACH_HTAB_ELEMENT (src->vars, var, variable, hi)
+ variable_union (var, dst);
}
/* Whether the value is currently being expanded. */
@@ -2605,7 +2458,7 @@ find_loc_in_1pdv (rtx loc, variable var,
gcc_checking_assert (!node->next);
dv = dv_from_value (node->loc);
- rvar = (variable) htab_find_with_hash (vars, dv, dv_htab_hash (dv));
+ rvar = htab_find_dv (vars, dv);
return find_loc_in_1pdv (loc, rvar, vars);
}
@@ -2694,8 +2547,7 @@ intersect_loc_chains (rtx val, location_
if (s1node->loc == val)
continue;
- if ((found = find_loc_in_1pdv (s1node->loc, s2var,
- shared_hash_htab (s2set->vars))))
+ if ((found = find_loc_in_1pdv (s1node->loc, s2var, s2set->vars)))
{
insert_into_intersection (dest, s1node->loc,
MIN (s1node->init, found->init));
@@ -2706,7 +2558,7 @@ intersect_loc_chains (rtx val, location_
&& !VALUE_RECURSED_INTO (s1node->loc))
{
decl_or_value dv = dv_from_value (s1node->loc);
- variable svar = shared_hash_find (s1set->vars, dv);
+ variable svar = htab_find_dv (s1set->vars, dv);
if (svar)
{
if (svar->n_var_parts == 1)
@@ -2924,8 +2776,7 @@ add_value_chain (rtx *loc, void *dvp)
return 0;
dv = (decl_or_value) dvp;
- slot = htab_find_slot_with_hash (value_chains, ldv, dv_htab_hash (ldv),
- INSERT);
+ slot = htab_slot_dv (value_chains, ldv, INSERT);
if (!*slot)
{
vc = (value_chain) pool_alloc (value_chain_pool);
@@ -3013,8 +2864,7 @@ remove_value_chain (rtx *loc, void *dvp)
return 0;
dv = (decl_or_value) dvp;
- slot = htab_find_slot_with_hash (value_chains, ldv, dv_htab_hash (ldv),
- NO_INSERT);
+ slot = htab_slot_dv (value_chains, ldv, NO_INSERT);
for (vc = (value_chain) *slot; vc->next; vc = vc->next)
if (dv_as_opaque (vc->next->dv) == dv_as_opaque (dv))
{
@@ -3128,7 +2978,7 @@ canonicalize_values_mark (void **slot, v
else
{
decl_or_value odv = dv_from_value (node->loc);
- void **oslot = shared_hash_find_slot_noinsert (set->vars, odv);
+ void **oslot = htab_slot_dv (set->vars, odv, NO_INSERT);
set_slot_part (set, val, oslot, odv, 0,
node->init, NULL_RTX);
@@ -3209,7 +3059,7 @@ canonicalize_values_star (void **slot, v
restart_with_cval:
VALUE_RECURSED_INTO (cval) = false;
dv = dv_from_value (cval);
- slot = shared_hash_find_slot_noinsert (set->vars, dv);
+ slot = htab_slot_dv (set->vars, dv, NO_INSERT);
if (!slot)
{
gcc_assert (dv_is_decl_p (var->dv));
@@ -3233,7 +3083,7 @@ canonicalize_values_star (void **slot, v
/* Push values to the canonical one. */
cdv = dv_from_value (cval);
- cslot = shared_hash_find_slot_noinsert (set->vars, cdv);
+ cslot = htab_slot_dv (set->vars, cdv, NO_INSERT);
for (node = var->var_part[0].loc_chain; node; node = node->next)
if (node->loc != cval)
@@ -3393,7 +3243,7 @@ canonicalize_vars_star (void **slot, voi
/* Push values to the canonical one. */
cdv = dv_from_value (cval);
- cslot = shared_hash_find_slot_noinsert (set->vars, cdv);
+ cslot = htab_slot_dv (set->vars, cdv, NO_INSERT);
if (!cslot)
return 1;
cvar = (variable)*cslot;
@@ -3454,10 +3304,9 @@ variable_merge_over_cur (variable s1var,
else
val = NULL;
- s2var = shared_hash_find_1 (dsm->src->vars, dv, dvhash);
+ s2var = (variable) htab_find_with_hash (dsm->src->vars, dv, dvhash);
if (!s2var)
{
- dst_can_be_shared = false;
return 1;
}
@@ -3466,7 +3315,7 @@ variable_merge_over_cur (variable s1var,
&& s2var->n_var_parts == 1
&& s2var->var_part[0].offset == 0);
- dstslot = shared_hash_find_slot_noinsert_1 (dst->vars, dv, dvhash);
+ dstslot = htab_find_slot_with_hash (dst->vars, dv, dvhash, NO_INSERT);
if (dstslot)
{
dvar = (variable)*dstslot;
@@ -3483,15 +3332,13 @@ variable_merge_over_cur (variable s1var,
if (!dstslot && !onepart_variable_different_p (s1var, s2var))
{
- dstslot = shared_hash_find_slot_unshare_1 (&dst->vars, dv,
- dvhash, INSERT);
+ dstslot = htab_find_slot_with_hash (dst->vars, dv,
+ dvhash, INSERT);
*dstslot = dvar = s2var;
dvar->refcount++;
}
else
{
- dst_can_be_shared = false;
-
intersect_loc_chains (val, nodep, dsm,
s1var->var_part[0].loc_chain, s2var);
@@ -3509,9 +3356,8 @@ variable_merge_over_cur (variable s1var,
dvar->var_part[0].loc_chain = node;
dvar->var_part[0].cur_loc = NULL;
- dstslot
- = shared_hash_find_slot_unshare_1 (&dst->vars, dv, dvhash,
- INSERT);
+ dstslot = htab_find_slot_with_hash (dst->vars, dv,
+ dvhash, INSERT);
gcc_assert (!*dstslot);
*dstslot = dvar;
}
@@ -3581,12 +3427,12 @@ variable_merge_over_cur (variable s1var,
node->init, NULL, INSERT);
}
- dstslot = shared_hash_find_slot_noinsert_1 (dst->vars, dv, dvhash);
+ dstslot = htab_find_slot_with_hash (dst->vars, dv, dvhash, NO_INSERT);
gcc_assert (*dstslot == dvar);
canonicalize_values_star (dstslot, dst);
gcc_checking_assert (dstslot
- == shared_hash_find_slot_noinsert_1 (dst->vars,
- dv, dvhash));
+ == htab_find_slot_with_hash (dst->vars, dv,
+ dvhash, NO_INSERT));
dvar = (variable)*dstslot;
}
else
@@ -3625,11 +3471,10 @@ variable_merge_over_cur (variable s1var,
decl_or_value dv = dv_from_value (node->loc);
void **slot = NULL;
- if (shared_hash_shared (dst->vars))
- slot = shared_hash_find_slot_noinsert (dst->vars, dv);
- if (!slot)
- slot = shared_hash_find_slot_unshare (&dst->vars, dv,
- INSERT);
+ /* if (shared_hash_shared (dst->vars)) */
+ /* slot = shared_hash_find_slot_noinsert (dst->vars, dv); */
+ /* if (!slot) */
+ slot = htab_slot_dv (dst->vars, dv, INSERT);
if (!*slot)
{
variable var = (variable) pool_alloc (dv_pool (dv));
@@ -3648,12 +3493,12 @@ variable_merge_over_cur (variable s1var,
}
}
- dstslot = shared_hash_find_slot_noinsert_1 (dst->vars, dv, dvhash);
+ dstslot = htab_find_slot_with_hash (dst->vars, dv, dvhash, NO_INSERT);
gcc_assert (*dstslot == dvar);
canonicalize_values_star (dstslot, dst);
gcc_checking_assert (dstslot
- == shared_hash_find_slot_noinsert_1 (dst->vars,
- dv, dvhash));
+ == htab_find_slot_with_hash (dst->vars, dv,
+ dvhash, NO_INSERT));
dvar = (variable)*dstslot;
}
}
@@ -3669,10 +3514,7 @@ variable_merge_over_cur (variable s1var,
variable_htab_free (dvar);
*dstslot = dvar = s1var;
dvar->refcount++;
- dst_can_be_shared = false;
}
- else
- dst_can_be_shared = false;
return 1;
}
@@ -3691,7 +3533,7 @@ variable_merge_over_src (variable s2var,
if (!onepart)
{
- void **dstp = shared_hash_find_slot (dst->vars, dv);
+ void **dstp = htab_slot_dv (dst->vars, dv, INSERT);
*dstp = s2var;
s2var->refcount++;
return 1;
@@ -3707,7 +3549,7 @@ variable_merge_over_src (variable s2var,
static void
dataflow_set_merge (dataflow_set *dst, dataflow_set *src2)
{
- dataflow_set cur = *dst;
+ dataflow_set cur = *dst; /* Keep original dst as src1 */
dataflow_set *src1 = &cur;
struct dfset_merge dsm;
int i;
@@ -3715,16 +3557,15 @@ dataflow_set_merge (dataflow_set *dst, d
htab_iterator hi;
variable var;
- src1_elems = htab_elements (shared_hash_htab (src1->vars));
- src2_elems = htab_elements (shared_hash_htab (src2->vars));
- dataflow_set_init (dst);
+ src1_elems = htab_elements (src1->vars);
+ src2_elems = htab_elements (src2->vars);
+
+ memset (dst->regs, 0, sizeof (dst->regs));
+ /* htab_empty (dst->vars); */
+ dst->vars = htab_create (2 * MAX (src1_elems, src2_elems), variable_htab_hash,
+ variable_htab_eq, variable_htab_free);
+ dst->traversed_vars = NULL;
dst->stack_adjust = cur.stack_adjust;
- shared_hash_destroy (dst->vars, true);
- dst->vars = (shared_hash) pool_alloc (shared_hash_pool);
- dst->vars->refcount = 1;
- dst->vars->htab
- = htab_create (2 * MAX (src1_elems, src2_elems), variable_htab_hash,
- variable_htab_eq, variable_htab_free);
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
attrs_list_mpdv_union (&dst->regs[i], src1->regs[i], src2->regs[i]);
@@ -3734,14 +3575,11 @@ dataflow_set_merge (dataflow_set *dst, d
dsm.cur = src1;
dsm.src_onepart_cnt = 0;
- FOR_EACH_HTAB_ELEMENT (shared_hash_htab (dsm.src->vars), var, variable, hi)
+ FOR_EACH_HTAB_ELEMENT (dsm.src->vars, var, variable, hi)
variable_merge_over_src (var, &dsm);
- FOR_EACH_HTAB_ELEMENT (shared_hash_htab (dsm.cur->vars), var, variable, hi)
+ FOR_EACH_HTAB_ELEMENT (dsm.cur->vars, var, variable, hi)
variable_merge_over_cur (var, &dsm);
- if (dsm.src_onepart_cnt)
- dst_can_be_shared = false;
-
dataflow_set_destroy (src1, true);
}
@@ -3818,7 +3656,7 @@ dataflow_set_equiv_regs (dataflow_set *s
continue;
}
- slot = shared_hash_find_slot_noinsert (set->vars, list->dv);
+ slot = htab_slot_dv (set->vars, list->dv, NO_INSERT);
canonicalize_values_star (slot, set);
if (*listp != list)
list = NULL;
@@ -4032,8 +3870,7 @@ variable_post_merge_perm_vals (void **ps
&& REG_P (pnode->loc));
dv = pvar->dv;
-
- var = shared_hash_find (set->vars, dv);
+ var = htab_find_dv (set->vars, dv);
if (var)
{
/* Although variable_post_merge_new_vals may have made decls
@@ -4042,7 +3879,7 @@ variable_post_merge_perm_vals (void **ps
REG, so they are canonical as well. Since VAR has the
location list for a VALUE, using find_loc_in_1pdv for it is
fine, since VALUEs don't map back to DECLs. */
- if (find_loc_in_1pdv (pnode->loc, var, shared_hash_htab (set->vars)))
+ if (find_loc_in_1pdv (pnode->loc, var, set->vars))
return 1;
val_reset (set, dv);
}
@@ -4083,13 +3920,11 @@ dataflow_post_merge_adjust (dataflow_set
dfpm.set = set;
dfpm.permp = permp;
- htab_traverse (shared_hash_htab (set->vars), variable_post_merge_new_vals,
- &dfpm);
+ htab_traverse (set->vars, variable_post_merge_new_vals, &dfpm);
if (*permp)
- htab_traverse (shared_hash_htab ((*permp)->vars),
- variable_post_merge_perm_vals, &dfpm);
- htab_traverse (shared_hash_htab (set->vars), canonicalize_values_star, set);
- htab_traverse (shared_hash_htab (set->vars), canonicalize_vars_star, set);
+ htab_traverse ((*permp)->vars, variable_post_merge_perm_vals, &dfpm);
+ htab_traverse (set->vars, canonicalize_values_star, set);
+ htab_traverse (set->vars, canonicalize_vars_star, set);
}
/* Return a node whose loc is a MEM that refers to EXPR in the
@@ -4111,7 +3946,7 @@ find_mem_expr_in_1pdv (tree expr, rtx va
&& !VALUE_RECURSED_INTO (val));
dv = dv_from_value (val);
- var = (variable) htab_find_with_hash (vars, dv, dv_htab_hash (dv));
+ var = htab_find_dv (vars, dv);
if (!var)
return NULL;
@@ -4187,7 +4022,7 @@ dataflow_set_preserve_mem_locs (void **s
gcc_assert (var->n_var_parts == 1);
- if (shared_var_p (var, set->vars))
+ if (shared_var_p (var))
{
for (loc = var->var_part[0].loc_chain; loc; loc = loc->next)
{
@@ -4199,8 +4034,7 @@ dataflow_set_preserve_mem_locs (void **s
break;
/* We want to move here MEMs that do refer to DECL. */
else if (GET_CODE (loc->loc) == VALUE
- && find_mem_expr_in_1pdv (decl, loc->loc,
- shared_hash_htab (set->vars)))
+ && find_mem_expr_in_1pdv (decl, loc->loc, set->vars))
break;
}
@@ -4219,8 +4053,7 @@ dataflow_set_preserve_mem_locs (void **s
if (GET_CODE (old_loc) == VALUE)
{
location_chain mem_node
- = find_mem_expr_in_1pdv (decl, loc->loc,
- shared_hash_htab (set->vars));
+ = find_mem_expr_in_1pdv (decl, loc->loc, set->vars);
/* ??? This picks up only one out of multiple MEMs that
refer to the same variable. Do we ever need to be
@@ -4298,7 +4131,7 @@ dataflow_set_remove_mem_locs (void **slo
gcc_assert (var->n_var_parts == 1);
- if (shared_var_p (var, set->vars))
+ if (shared_var_p (var))
{
for (loc = var->var_part[0].loc_chain; loc; loc = loc->next)
if (GET_CODE (loc->loc) == MEM
@@ -4365,11 +4198,9 @@ dataflow_set_clear_at_call (dataflow_set
if (MAY_HAVE_DEBUG_INSNS)
{
set->traversed_vars = set->vars;
- htab_traverse (shared_hash_htab (set->vars),
- dataflow_set_preserve_mem_locs, set);
+ htab_traverse (set->vars, dataflow_set_preserve_mem_locs, set);
set->traversed_vars = set->vars;
- htab_traverse (shared_hash_htab (set->vars), dataflow_set_remove_mem_locs,
- set);
+ htab_traverse (set->vars, dataflow_set_remove_mem_locs, set);
set->traversed_vars = NULL;
}
}
@@ -4470,15 +4301,12 @@ dataflow_set_different (dataflow_set *ol
if (old_set->vars == new_set->vars)
return false;
- if (htab_elements (shared_hash_htab (old_set->vars))
- != htab_elements (shared_hash_htab (new_set->vars)))
+ if (htab_elements (old_set->vars) != htab_elements (new_set->vars))
return true;
- FOR_EACH_HTAB_ELEMENT (shared_hash_htab (old_set->vars), var1, variable, hi)
+ FOR_EACH_HTAB_ELEMENT (old_set->vars, var1, variable, hi)
{
- htab_t htab = shared_hash_htab (new_set->vars);
- variable var2 = (variable) htab_find_with_hash (htab, var1->dv,
- dv_htab_hash (var1->dv));
+ variable var2 = htab_find_dv (new_set->vars, var1->dv);
if (!var2)
{
if (dump_file && (dump_flags & TDF_DETAILS))
@@ -4519,7 +4347,10 @@ dataflow_set_destroy (dataflow_set *set,
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
attrs_list_clear (&set->regs[i]);
- shared_hash_destroy (set->vars, do_free);
+ if (!do_free)
+ /* Dirty hack to prevent htab_delete() iterating over all elements */
+ set->vars->del_f = NULL;
+ htab_delete (set->vars);
set->vars = NULL;
}
@@ -6039,7 +5870,7 @@ find_src_set_src (dataflow_set *set, rtx
{
decl_or_value dv = dv_from_decl (decl);
- var = shared_hash_find (set->vars, dv);
+ var = htab_find_dv (set->vars, dv);
if (var)
{
found = false;
@@ -6338,13 +6169,10 @@ compute_bb_dataflow (basic_block bb)
if (MAY_HAVE_DEBUG_INSNS)
{
dataflow_set_equiv_regs (out);
- htab_traverse (shared_hash_htab (out->vars), canonicalize_values_mark,
- out);
- htab_traverse (shared_hash_htab (out->vars), canonicalize_values_star,
- out);
+ htab_traverse (out->vars, canonicalize_values_mark, out);
+ htab_traverse (out->vars, canonicalize_values_star, out);
#if ENABLE_CHECKING
- htab_traverse (shared_hash_htab (out->vars),
- canonicalize_loc_order_check, out);
+ htab_traverse (out->vars, canonicalize_loc_order_check, out);
#endif
}
changed = dataflow_set_different (&old_out, out);
@@ -6415,27 +6243,24 @@ vt_find_locations (void)
if (VTI (bb)->in.vars)
{
- htabsz
- -= (htab_size (shared_hash_htab (VTI (bb)->in.vars))
- + htab_size (shared_hash_htab (VTI (bb)->out.vars)));
- oldinsz
- = htab_elements (shared_hash_htab (VTI (bb)->in.vars));
- oldoutsz
- = htab_elements (shared_hash_htab (VTI (bb)->out.vars));
+ htabsz -= (htab_size (VTI (bb)->in.vars)
+ + htab_size (VTI (bb)->out.vars));
+ oldinsz = htab_elements (VTI (bb)->in.vars);
+ oldoutsz = htab_elements (VTI (bb)->out.vars);
}
else
oldinsz = oldoutsz = 0;
if (MAY_HAVE_DEBUG_INSNS)
{
- dataflow_set *in = &VTI (bb)->in, *first_out = NULL;
+ dataflow_set *in = &VTI (bb)->in;
+ /* dataflow_set *first_out = NULL; */
bool first = true, adjust = false;
/* Calculate the IN set as the intersection of
predecessor OUT sets. */
dataflow_set_clear (in);
- dst_can_be_shared = true;
FOR_EACH_EDGE (e, ei, bb->preds)
if (!VTI (e->src)->flooded)
@@ -6444,7 +6269,7 @@ vt_find_locations (void)
else if (first)
{
dataflow_set_copy (in, &VTI (e->src)->out);
- first_out = &VTI (e->src)->out;
+ /* first_out = &VTI (e->src)->out; */
first = false;
}
else
@@ -6459,15 +6284,9 @@ vt_find_locations (void)
#if ENABLE_CHECKING
/* Merge and merge_adjust should keep entries in
canonical order. */
- htab_traverse (shared_hash_htab (in->vars),
- canonicalize_loc_order_check,
+ htab_traverse (in->vars, canonicalize_loc_order_check,
in);
#endif
- if (dst_can_be_shared)
- {
- shared_hash_destroy (in->vars, true);
- in->vars = shared_hash_copy (first_out->vars);
- }
}
VTI (bb)->flooded = true;
@@ -6481,8 +6300,8 @@ vt_find_locations (void)
}
changed = compute_bb_dataflow (bb);
- htabsz += (htab_size (shared_hash_htab (VTI (bb)->in.vars))
- + htab_size (shared_hash_htab (VTI (bb)->out.vars)));
+ htabsz += (htab_size (VTI (bb)->in.vars)
+ + htab_size (VTI (bb)->out.vars));
if (htabmax && htabsz > htabmax)
{
@@ -6529,11 +6348,11 @@ vt_find_locations (void)
fprintf (dump_file,
"BB %i: in %i (was %i), out %i (was %i), rem %i + %i, tsz %i\n",
bb->index,
- (int)htab_elements (shared_hash_htab (VTI (bb)->in.vars)),
+ (int) htab_elements (VTI (bb)->in.vars),
oldinsz,
- (int)htab_elements (shared_hash_htab (VTI (bb)->out.vars)),
+ (int) htab_elements (VTI (bb)->out.vars),
oldoutsz,
- (int)worklist->nodes, (int)pending->nodes, htabsz);
+ (int) worklist->nodes, (int) pending->nodes, htabsz);
if (dump_file && (dump_flags & TDF_DETAILS))
{
@@ -6664,7 +6483,7 @@ dump_dataflow_set (dataflow_set *set)
dump_attrs_list (set->regs[i]);
}
}
- dump_vars (shared_hash_htab (set->vars));
+ dump_vars (set->vars);
fprintf (dump_file, "\n");
}
@@ -6745,14 +6564,9 @@ variable_was_changed (variable var, data
void **slot;
drop_var:
- slot = shared_hash_find_slot_noinsert (set->vars, var->dv);
+ slot = htab_slot_dv (set->vars, var->dv, NO_INSERT);
if (slot)
- {
- if (shared_hash_shared (set->vars))
- slot = shared_hash_find_slot_unshare (&set->vars, var->dv,
- NO_INSERT);
- htab_clear_slot (shared_hash_htab (set->vars), slot);
- }
+ htab_clear_slot (set->vars, slot);
}
}
}
@@ -6913,7 +6727,7 @@ set_slot_part (dataflow_set *set, rtx lo
if (r == 0)
return slot;
- if (shared_var_p (var, set->vars))
+ if (shared_var_p (var))
{
slot = unshare_variable (set, slot, var, initialized);
var = (variable)*slot;
@@ -6952,7 +6766,7 @@ set_slot_part (dataflow_set *set, rtx lo
else
{
/* We have to make a copy of a shared variable. */
- if (shared_var_p (var, set->vars))
+ if (shared_var_p (var))
{
slot = unshare_variable (set, slot, var, initialized);
var = (variable)*slot;
@@ -6964,7 +6778,7 @@ set_slot_part (dataflow_set *set, rtx lo
/* We have not found the location part, new one will be created. */
/* We have to make a copy of the shared variable. */
- if (shared_var_p (var, set->vars))
+ if (shared_var_p (var))
{
slot = unshare_variable (set, slot, var, initialized);
var = (variable)*slot;
@@ -7049,14 +6863,8 @@ set_variable_part (dataflow_set *set, rt
{
void **slot;
- if (iopt == NO_INSERT)
- slot = shared_hash_find_slot_noinsert (set->vars, dv);
- else
- {
- slot = shared_hash_find_slot (set->vars, dv);
- if (!slot)
- slot = shared_hash_find_slot_unshare (&set->vars, dv, iopt);
- }
+ slot = htab_slot_dv (set->vars, dv, iopt);
+
set_slot_part (set, loc, slot, dv, offset, initialized, set_src);
}
@@ -7134,7 +6942,7 @@ clobber_variable_part (dataflow_set *set
|| (!dv_is_value_p (dv) && ! DECL_P (dv_as_decl (dv))))
return;
- slot = shared_hash_find_slot_noinsert (set->vars, dv);
+ slot = htab_slot_dv (set->vars, dv, NO_INSERT);
if (!slot)
return;
@@ -7158,7 +6966,7 @@ delete_slot_part (dataflow_set *set, rtx
location_chain *nextp;
bool changed;
- if (shared_var_p (var, set->vars))
+ if (shared_var_p (var))
{
/* If the variable contains the location part we have to
make a copy of the variable. */
@@ -7233,7 +7041,7 @@ static void
delete_variable_part (dataflow_set *set, rtx loc, decl_or_value dv,
HOST_WIDE_INT offset)
{
- void **slot = shared_hash_find_slot_noinsert (set->vars, dv);
+ void **slot = htab_slot_dv (set->vars, dv, NO_INSERT);
if (!slot)
return;
@@ -7330,7 +7138,7 @@ vt_expand_loc_callback (rtx x, bitmap re
if (VALUE_RECURSED_INTO (x))
return NULL;
- var = (variable) htab_find_with_hash (elcd->vars, dv, dv_htab_hash (dv));
+ var = htab_find_dv (elcd->vars, dv);
if (!var)
{
@@ -7710,19 +7518,18 @@ static VEC (rtx, heap) *changed_values_s
/* Helper function for check_changed_vars_1 and check_changed_vars_2. */
static void
-check_changed_vars_0 (decl_or_value dv, htab_t htab)
+check_changed_vars_0 (decl_or_value dv, htab_t vars)
{
value_chain vc
- = (value_chain) htab_find_with_hash (value_chains, dv, dv_htab_hash (dv));
+ = (value_chain) htab_find_with_hash (value_chains, dv,
+ dv_htab_hash (dv));
if (vc == NULL)
return;
for (vc = vc->next; vc; vc = vc->next)
if (!dv_changed_p (vc->dv))
{
- variable vcvar
- = (variable) htab_find_with_hash (htab, vc->dv,
- dv_htab_hash (vc->dv));
+ variable vcvar = htab_find_dv (vars, vc->dv);
if (vcvar)
{
set_dv_changed (vc->dv, true);
@@ -7733,7 +7540,7 @@ check_changed_vars_0 (decl_or_value dv,
set_dv_changed (vc->dv, true);
VEC_safe_push (rtx, heap, changed_values_stack,
dv_as_value (vc->dv));
- check_changed_vars_0 (vc->dv, htab);
+ check_changed_vars_0 (vc->dv, vars);
}
}
}
@@ -7813,11 +7620,9 @@ check_changed_vars_3 (void **slot, void
shall be emitted before of after instruction INSN. */
static void
-emit_notes_for_changes (rtx insn, enum emit_note_where where,
- shared_hash vars)
+emit_notes_for_changes (rtx insn, enum emit_note_where where, htab_t vars)
{
emit_note_data data;
- htab_t htab = shared_hash_htab (vars);
if (!htab_elements (changed_variables))
return;
@@ -7827,19 +7632,19 @@ emit_notes_for_changes (rtx insn, enum e
/* Unfortunately this has to be done in two steps, because
we can't traverse a hashtab into which we are inserting
through variable_was_changed. */
- htab_traverse (changed_variables, check_changed_vars_1, htab);
+ htab_traverse (changed_variables, check_changed_vars_1, vars);
while (VEC_length (variable, changed_variables_stack) > 0)
check_changed_vars_2 (VEC_pop (variable, changed_variables_stack),
- htab);
+ vars);
while (VEC_length (rtx, changed_values_stack) > 0)
set_dv_changed (dv_from_value (VEC_pop (rtx, changed_values_stack)),
false);
- htab_traverse (changed_variables, check_changed_vars_3, htab);
+ htab_traverse (changed_variables, check_changed_vars_3, vars);
}
data.insn = insn;
data.where = where;
- data.vars = htab;
+ data.vars = vars;
htab_traverse (changed_variables, emit_note_insn_var_location, &data);
}
@@ -7854,8 +7659,7 @@ emit_notes_for_differences_1 (void **slo
variable old_var, new_var;
old_var = (variable) *slot;
- new_var = (variable) htab_find_with_hash (new_vars, old_var->dv,
- dv_htab_hash (old_var->dv));
+ new_var = htab_find_dv (new_vars, old_var->dv);
if (!new_var)
{
@@ -7947,8 +7751,7 @@ emit_notes_for_differences_2 (void **slo
variable old_var, new_var;
new_var = (variable) *slot;
- old_var = (variable) htab_find_with_hash (old_vars, new_var->dv,
- dv_htab_hash (new_var->dv));
+ old_var = htab_find_dv(old_vars, new_var->dv);
if (!old_var)
{
int i;
@@ -7977,12 +7780,8 @@ static void
emit_notes_for_differences (rtx insn, dataflow_set *old_set,
dataflow_set *new_set)
{
- htab_traverse (shared_hash_htab (old_set->vars),
- emit_notes_for_differences_1,
- shared_hash_htab (new_set->vars));
- htab_traverse (shared_hash_htab (new_set->vars),
- emit_notes_for_differences_2,
- shared_hash_htab (old_set->vars));
+ htab_traverse (old_set->vars, emit_notes_for_differences_1, new_set->vars);
+ htab_traverse (new_set->vars, emit_notes_for_differences_2, old_set->vars);
emit_notes_for_changes (insn, EMIT_NOTE_BEFORE_INSN, new_set->vars);
}
@@ -8011,8 +7810,7 @@ emit_notes_in_bb (basic_block bb, datafl
while (*p)
{
XEXP (XEXP (*p, 0), 1)
- = vt_expand_loc (XEXP (XEXP (*p, 0), 1),
- shared_hash_htab (set->vars), true);
+ = vt_expand_loc (XEXP (XEXP (*p, 0), 1), set->vars, true);
/* If expansion is successful, keep it in the list. */
if (XEXP (XEXP (*p, 0), 1))
p = &XEXP (*p, 1);
@@ -8339,9 +8137,7 @@ vt_emit_notes (void)
dataflow_set_clear (&VTI (bb)->in);
}
#ifdef ENABLE_CHECKING
- htab_traverse (shared_hash_htab (cur.vars),
- emit_notes_for_differences_1,
- shared_hash_htab (empty_shared_hash));
+ htab_traverse (cur.vars, emit_notes_for_differences_1, empty_htab);
if (MAY_HAVE_DEBUG_INSNS)
{
unsigned int i;
@@ -8703,13 +8499,9 @@ vt_initialize (void)
loc_chain_pool = create_alloc_pool ("location_chain_def pool",
sizeof (struct location_chain_def),
1024);
- shared_hash_pool = create_alloc_pool ("shared_hash_def pool",
- sizeof (struct shared_hash_def), 256);
- empty_shared_hash = (shared_hash) pool_alloc (shared_hash_pool);
- empty_shared_hash->refcount = 1;
- empty_shared_hash->htab
- = htab_create (1, variable_htab_hash, variable_htab_eq,
- variable_htab_free);
+ /* htab_pool = create_alloc_pool ("htab pool", sizeof (*htab_t), 256); */
+ empty_htab = htab_create (1, variable_htab_hash, variable_htab_eq,
+ variable_htab_free);
changed_variables = htab_create (10, variable_htab_hash, variable_htab_eq,
variable_htab_free);
if (MAY_HAVE_DEBUG_INSNS)
@@ -9017,12 +8809,11 @@ vt_finalize (void)
}
}
free_aux_for_blocks ();
- htab_delete (empty_shared_hash->htab);
+ htab_delete (empty_htab);
htab_delete (changed_variables);
free_alloc_pool (attrs_pool);
free_alloc_pool (var_pool);
free_alloc_pool (loc_chain_pool);
- free_alloc_pool (shared_hash_pool);
if (MAY_HAVE_DEBUG_INSNS)
{