+2005-06-29 Daniel Berlin <dberlin@dberlin.org>
+
+ * tree-complex.c (complex_variable_components): Now a hashtable.
+ (cvc_lookup): Ditto.
+ (cvc_insert): Ditto.
+ (create_components): Use referenced var iterator.
+ Initialize hashtable. Use cvc_insert/lookup.
+ (extract_components): Use cvc_insert/lookup.
+ (update_complex_components): Ditto.
+ (update_complex_components_on_edge): Ditto.
+ * tree-dfa.c (referenced_vars): Now a hashtable.
+ (dump_referenced_vars): Use iterator.
+ (referenced_var_lookup): New function.
+ (referenced_var_insert): Ditto.
+ (add_referenced_var): Use referenced_var_insert.
+ (mark_new_vars_to_rename): Use DECL_UID.
+ * tree-flow-inline.h (first_htab_element): New function.
+ (end_htab_p): Ditto.
+ (next_htab_element): Ditto.
+ (first_referenced_var): Ditto.
+ (end_referenced_vars_p): Ditto.
+ (next_referenced_var): Ditto.
+ (is_call_clobbered): Use DECL_UID.
+ (mark_call_clobbered): Ditto.
+ (clear_call_clobbered): Ditto.
+ (mark_non_addressable): Ditto.
+ * tree-flow.h (htab_iterator): New struct.
+ (FOR_EACH_HTAB_ELEMENT): New macro.
+ (struct int_tree_map): New struct.
+ (int_tree_map_hash): Prototype.
+ (int_tree_map_eq): Ditto.
+ (referenced_var_iterator): Ditto.
+ (FOR_EACH_REFERENCED_VAR): New macro.
+ (referenced_vars): Now a hashtable.
+ * tree-into-ssa.c (symbol_marked_for_renaming): Use DECL_UID.
+ (add_new_name_mapping): Ditto.
+ (mark_def_sites): Ditto.
+ (insert_phi_nodes): Use referenced_var iterator.
+ (mark_def_site_blocks): Ditto.
+ (mark_sym_for_renaming): Use DECL_UID.
+ * tree-sra.c (is_sra_candidate_decl): Use DECL_UID.
+ (lookup_element): Ditto.
+ (find_candidates_for_sra): Use referenced_vars iterator.
+ Use DECL_UID.
+ * tree-ssa-alias.c (NUM_REFERENCES): New macro.
+ (NUM_REFERENCES_CLEAR): Ditto.
+ (NUM_REFERENCES_INC): Ditto.
+ (NUM_REFERENCES_SET): Ditto.
+ (alias_obstack): New bitmap obstack.
+ (struct alias_map_d): Use bitmap, not sbitmap.
+ (struct alias_info): Remove num_references.
+ (init_alias_info): Use referenced_var iterator.
+ Initialize bitmap obstack.
+ (delete_alias_info): Use referenced_var iterator.
+ Free bitmap obstack.
+ (compute_points_to_and_addr_escape): Use DECL_UID.
+ Use new NUM_REFERENCES macros.
+ (compute_flow_sensitive_aliasing): may_aliases is now a bitmap.
+ Use new NUM_REFERENCES macros.
+ (group_aliases_into): Update prototype to use bitmap.
+ (setup_pointers_and_addressables): Use referenced_vars iterator.
+ Use DECL_UID. Use new NUM_REFERENCES macros.
+ (add_pointed_to_var): Use DECL_UID.
+ (dump_alias_info): Use referenced_var iterator.
+ (add_type_alias): Ditto.
+ (used_portions): Now a hashtable.
+ (used_part_map_eq): New function.
+ (used_part_map_hash): Ditto.
+ (free_used_part_map): Ditto.
+ (up_lookup): Ditto.
+ (up_insert): Ditto.
+ (get_or_create_used_part_for): Use up_lookup.
+ (create_overlap_variables_for): Ditto.
+ (find_used_portions): Use up_insert.
+ Use DECL_UID.
+ (create_structure_vars): Init used_portions hashtable, use
+ referenced_vars iterator.
+ * tree-ssa-live.c (create_ssa_var_map): sbitmaps became bitmaps.
+ Use DECL_UID.
+ * tree-ssa-loop-im.c (gather_mem_refs_stmt): Use DECL_UID.
+ * tree-ssa-operands.c (get_asm_expr_operands): Ditto.
+ (note_addressable): Ditto.
+ * tree-ssa-structalias.c (set_uids_in_ptset): Ditto.
+ * tree-ssa.c (verify_flow_insensitive_alias_info): Use
+ referenced_var iterator.
+ Use DECL_UID.
+ (delete_tree_ssa): Ditto.
+ (int_tree_map_eq): New function.
+ (int_tree_map_hash): Ditto.
+ * tree-stdarg.c (find_va_list_reference): Use DECL_UID.
+ (va_list_ptr_read): Ditto.
+ (va_list_counter_struct_op): Ditto.
+ (va_list_ptr_write): Ditto.
+ (check_va_list_escapes): Ditto.
+ (check_all_va_list_escapes): Ditto.
+ (execute_optimize_stdarg): Ditto.
+ * tree-tailcall.c (suitable_for_tail_opt_p): Used referenced_var
+ iterator.
+
2005-06-30 Andrew Pinski <pinskia@physics.uc.edu>
* config/rs6000/darwin.h (FRAME_POINTER_REGNUM): Rename to ...
static VEC(complex_lattice_t, heap) *complex_lattice_values;
-/* For each complex variable, a pair of variables for the components. */
-static VEC(tree, heap) *complex_variable_components;
+/* For each complex variable, a pair of variables for the components exists in
+ the hashtable. */
+static htab_t complex_variable_components;
+
+/* Lookup UID in the complex_variable_components hashtable and return the
+ associated tree. */
+static tree
+cvc_lookup (unsigned int uid)
+{
+ struct int_tree_map *h, in;
+ in.uid = uid;
+ h = htab_find_with_hash (complex_variable_components, &in, uid);
+ gcc_assert (h);
+ return h->to;
+}
+
+/* Insert the pair UID, TO into the complex_variable_components hashtable. */
+
+static void
+cvc_insert (unsigned int uid, tree to)
+{
+ struct int_tree_map *h;
+ void **loc;
+
+ h = xmalloc (sizeof (struct int_tree_map));
+ h->uid = uid;
+ h->to = to;
+ loc = htab_find_slot_with_hash (complex_variable_components, h,
+ uid, INSERT);
+ *(struct int_tree_map **) loc = h;
+}
/* Return true if T is not a zero constant. In the case of real values,
static void
create_components (void)
{
- size_t k, n;
+ size_t n;
+ tree var;
+ referenced_var_iterator rvi;
n = num_referenced_vars;
if (n == 0)
return;
- complex_variable_components = VEC_alloc (tree, heap, 2*n);
- VEC_safe_grow (tree, heap, complex_variable_components, 2*n);
+ complex_variable_components = htab_create (10, int_tree_map_hash,
+ int_tree_map_eq, free);
- for (k = 0; k < n; ++k)
+ FOR_EACH_REFERENCED_VAR (var, rvi)
{
- tree var = referenced_var (k);
tree r = NULL, i = NULL;
if (var != NULL
}
}
- VEC_replace (tree, complex_variable_components, 2*k, r);
- VEC_replace (tree, complex_variable_components, 2*k + 1, i);
+ cvc_insert (2 * DECL_UID (var), r);
+ cvc_insert (2 * DECL_UID (var) + 1, i);
}
}
}
}
- return VEC_index (tree, complex_variable_components,
- var_ann (SSA_NAME_VAR (t))->uid * 2 + imagpart_p);
+ return cvc_lookup (DECL_UID (SSA_NAME_VAR (t)) * 2 + imagpart_p);
}
default:
static void
update_complex_components (block_stmt_iterator *bsi, tree stmt, tree r, tree i)
{
- unsigned int uid = var_ann (SSA_NAME_VAR (TREE_OPERAND (stmt, 0)))->uid;
+ unsigned int uid = DECL_UID (SSA_NAME_VAR (TREE_OPERAND (stmt, 0)));
tree v, x;
- v = VEC_index (tree, complex_variable_components, 2*uid);
+ v = cvc_lookup (2*uid);
x = build2 (MODIFY_EXPR, TREE_TYPE (v), v, r);
SET_EXPR_LOCUS (x, EXPR_LOCUS (stmt));
TREE_BLOCK (x) = TREE_BLOCK (stmt);
bsi_insert_after (bsi, x, BSI_NEW_STMT);
- v = VEC_index (tree, complex_variable_components, 2*uid + 1);
+ v = cvc_lookup (2*uid + 1);
x = build2 (MODIFY_EXPR, TREE_TYPE (v), v, i);
SET_EXPR_LOCUS (x, EXPR_LOCUS (stmt));
TREE_BLOCK (x) = TREE_BLOCK (stmt);
static void
update_complex_components_on_edge (edge e, tree stmt, tree lhs, tree r, tree i)
{
- unsigned int uid = var_ann (SSA_NAME_VAR (lhs))->uid;
+ unsigned int uid = DECL_UID (SSA_NAME_VAR (lhs));
tree v, x;
- v = VEC_index (tree, complex_variable_components, 2*uid);
+ v = cvc_lookup (2*uid);
x = build2 (MODIFY_EXPR, TREE_TYPE (v), v, r);
if (stmt)
{
}
bsi_insert_on_edge (e, x);
- v = VEC_index (tree, complex_variable_components, 2*uid + 1);
+ v = cvc_lookup (2*uid + 1);
x = build2 (MODIFY_EXPR, TREE_TYPE (v), v, i);
if (stmt)
{
bsi_commit_edge_inserts ();
- VEC_free (tree, heap, complex_variable_components);
+ if (complex_variable_components)
+ htab_delete (complex_variable_components);
+
VEC_free (complex_lattice_t, heap, complex_lattice_values);
}
/* Global declarations. */
/* Array of all variables referenced in the function. */
-VEC(tree,gc) *referenced_vars;
+htab_t referenced_vars;
/*---------------------------------------------------------------------------
void
dump_referenced_vars (FILE *file)
{
- size_t i;
-
+ tree var;
+ referenced_var_iterator rvi;
+
fprintf (file, "\nReferenced variables in %s: %u\n\n",
get_name (current_function_decl), (unsigned) num_referenced_vars);
-
- for (i = 0; i < num_referenced_vars; i++)
+
+ FOR_EACH_REFERENCED_VAR (var, rvi)
{
- tree var = referenced_var (i);
fprintf (file, "Variable: ");
dump_variable (file, var);
fprintf (file, "\n");
ann = var_ann (var);
- fprintf (file, ", UID %u", (unsigned) ann->uid);
+ fprintf (file, ", UID %u", (unsigned) DECL_UID (var));
fprintf (file, ", ");
print_generic_expr (file, TREE_TYPE (var), dump_flags);
}
+/* Lookup UID in the referenced_vars hashtable and return the associated
+ variable. */
+
+tree
+referenced_var_lookup (unsigned int uid)
+{
+ struct int_tree_map *h, in;
+ in.uid = uid;
+ h = htab_find_with_hash (referenced_vars, &in, uid);
+ gcc_assert (h || uid == 0);
+ if (h)
+ return h->to;
+ return NULL_TREE;
+}
+
+/* Insert the pair UID, TO into the referenced_vars hashtable. */
+
+static void
+referenced_var_insert (unsigned int uid, tree to)
+{
+ struct int_tree_map *h;
+ void **loc;
+
+ h = ggc_alloc (sizeof (struct int_tree_map));
+ h->uid = uid;
+ h->to = to;
+ loc = htab_find_slot_with_hash (referenced_vars, h, uid, INSERT);
+ *(struct int_tree_map **) loc = h;
+}
+
/* Add VAR to the list of dereferenced variables.
WALK_STATE contains a hash table used to avoid adding the same
intrinsic to the variable. */
if (slot)
*slot = (void *) var;
- v_ann->uid = num_referenced_vars;
- VEC_safe_push (tree, gc, referenced_vars, var);
+
+ referenced_var_insert (DECL_UID (var), var);
/* Global variables are always call-clobbered. */
if (is_global_var (var))
{
if (!DECL_P (val))
val = SSA_NAME_VAR (val);
- bitmap_set_bit (vars_in_vops_to_rename, var_ann (val)->uid);
+ bitmap_set_bit (vars_in_vops_to_rename, DECL_UID (val));
}
/* Now force an operand re-scan on the statement and mark any newly
/* Inline functions for manipulating various data structures defined in
tree-flow.h. See tree-flow.h for documentation. */
+/* Initialize the hashtable iterator HTI to point to hashtable TABLE */
+
+static inline void *
+first_htab_element (htab_iterator *hti, htab_t table)
+{
+ hti->htab = table;
+ hti->slot = table->entries;
+ hti->limit = hti->slot + htab_size (table);
+ do
+ {
+ PTR x = *(hti->slot);
+ if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY)
+ break;
+ } while (++(hti->slot) < hti->limit);
+
+ if (hti->slot < hti->limit)
+ return *(hti->slot);
+ return NULL;
+}
+
+/* Return current non-empty/deleted slot of the hashtable pointed to by HTI,
+ or NULL if we have reached the end. */
+
+static inline bool
+end_htab_p (htab_iterator *hti)
+{
+ if (hti->slot >= hti->limit)
+ return true;
+ return false;
+}
+
+/* Advance the hashtable iterator pointed by HTI to the next element of the
+ hashtable. */
+
+static inline void *
+next_htab_element (htab_iterator *hti)
+{
+ while (++(hti->slot) < hti->limit)
+ {
+ PTR x = *(hti->slot);
+ if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY)
+ return x;
+ };
+ return NULL;
+}
+
+/* Initialize ITER to point to the first referenced variable in the
+ referenced_vars hashtable, and return that variable. */
+
+static inline tree
+first_referenced_var (referenced_var_iterator *iter)
+{
+ struct int_tree_map *itm;
+ itm = first_htab_element (&iter->hti, referenced_vars);
+ if (!itm)
+ return NULL;
+ return itm->to;
+}
+
+/* Return true if we have hit the end of the referenced variables ITER is
+ iterating through. */
+
+static inline bool
+end_referenced_vars_p (referenced_var_iterator *iter)
+{
+ return end_htab_p (&iter->hti);
+}
+
+/* Make ITER point to the next referenced_var in the referenced_var hashtable,
+ and return that variable. */
+
+static inline tree
+next_referenced_var (referenced_var_iterator *iter)
+{
+ struct int_tree_map *itm;
+ itm = next_htab_element (&iter->hti);
+ if (!itm)
+ return NULL;
+ return itm->to;
+}
+
/* Return the variable annotation for T, which must be a _DECL node.
Return NULL if the variable annotation doesn't already exist. */
static inline var_ann_t
is_call_clobbered (tree var)
{
return is_global_var (var)
- || bitmap_bit_p (call_clobbered_vars, var_ann (var)->uid);
+ || bitmap_bit_p (call_clobbered_vars, DECL_UID (var));
}
/* Mark variable VAR as being clobbered by function calls. */
location in global memory. */
if (ann->mem_tag_kind != NOT_A_TAG && ann->mem_tag_kind != STRUCT_FIELD)
DECL_EXTERNAL (var) = 1;
- bitmap_set_bit (call_clobbered_vars, ann->uid);
+ bitmap_set_bit (call_clobbered_vars, DECL_UID (var));
ssa_call_clobbered_cache_valid = false;
ssa_ro_call_cache_valid = false;
}
var_ann_t ann = var_ann (var);
if (ann->mem_tag_kind != NOT_A_TAG && ann->mem_tag_kind != STRUCT_FIELD)
DECL_EXTERNAL (var) = 0;
- bitmap_clear_bit (call_clobbered_vars, ann->uid);
+ bitmap_clear_bit (call_clobbered_vars, DECL_UID (var));
ssa_call_clobbered_cache_valid = false;
ssa_ro_call_cache_valid = false;
}
static inline void
mark_non_addressable (tree var)
{
- bitmap_clear_bit (call_clobbered_vars, var_ann (var)->uid);
+ bitmap_clear_bit (call_clobbered_vars, DECL_UID (var));
TREE_ADDRESSABLE (var) = 0;
ssa_call_clobbered_cache_valid = false;
ssa_ro_call_cache_valid = false;
/* True if the code is in ssa form. */
extern bool in_ssa_p;
+typedef struct
+{
+ htab_t htab;
+ PTR *slot;
+ PTR *limit;
+} htab_iterator;
+
+/* Iterate through the elements of hashtable HTAB, using htab_iterator ITER,
+ storing each element in RESULT, which is of type TYPE. */
+#define FOR_EACH_HTAB_ELEMENT(HTAB, RESULT, TYPE, ITER) \
+ for (RESULT = (TYPE) first_htab_element (&(ITER), (HTAB)); \
+ !end_htab_p (&(ITER)); \
+ RESULT = (TYPE) next_htab_element (&(ITER)))
+
/*---------------------------------------------------------------------------
Attributes for SSA_NAMEs.
/* Variables that may alias this variable. */
varray_type may_aliases;
- /* Unique ID of this variable. */
- size_t uid;
-
/* Used when going out of SSA form to indicate which partition this
variable represents storage for. */
unsigned partition;
/*---------------------------------------------------------------------------
Global declarations
---------------------------------------------------------------------------*/
+struct int_tree_map GTY(())
+{
+
+ unsigned int uid;
+ tree to;
+};
+
+extern unsigned int int_tree_map_hash (const void *);
+extern int int_tree_map_eq (const void *, const void *);
+
+typedef struct
+{
+ htab_iterator hti;
+} referenced_var_iterator;
+
+
+#define FOR_EACH_REFERENCED_VAR(VAR, ITER) \
+ for ((VAR) = first_referenced_var (&(ITER)); \
+ !end_referenced_vars_p (&(ITER)); \
+ (VAR) = next_referenced_var (&(ITER)))
+
/* Array of all variables referenced in the function. */
-extern GTY(()) VEC(tree,gc) *referenced_vars;
+extern GTY((param_is (struct int_tree_map))) htab_t referenced_vars;
-#define num_referenced_vars VEC_length (tree, referenced_vars)
-#define referenced_var(i) VEC_index (tree, referenced_vars, i)
+extern tree referenced_var_lookup (unsigned int);
+#define num_referenced_vars htab_elements (referenced_vars)
+#define referenced_var(i) referenced_var_lookup (i)
/* Array of all SSA_NAMEs used in the function. */
extern GTY(()) VEC(tree,gc) *ssa_names;
symbol_marked_for_renaming (tree sym)
{
gcc_assert (DECL_P (sym));
- return bitmap_bit_p (syms_to_rename, var_ann (sym)->uid);
+ return bitmap_bit_p (syms_to_rename, DECL_UID (sym));
}
Otherwise, the insertion of PHI nodes for each of the old
names in these mappings will be very slow. */
sym = SSA_NAME_VAR (new);
- uid = var_ann (sym)->uid;
+ uid = DECL_UID (sym);
update_ssa_stats.num_virtual_mappings++;
if (!bitmap_bit_p (update_ssa_stats.virtual_symbols, uid))
{
{
tree sym = USE_FROM_PTR (use_p);
gcc_assert (DECL_P (sym));
- if (!bitmap_bit_p (kills, var_ann (sym)->uid))
+ if (!bitmap_bit_p (kills, DECL_UID (sym)))
set_livein_block (sym, bb);
REWRITE_THIS_STMT (stmt) = 1;
}
{
gcc_assert (DECL_P (def));
set_def_block (def, bb, false);
- bitmap_set_bit (kills, var_ann (def)->uid);
+ bitmap_set_bit (kills, DECL_UID (def));
REGISTER_DEFS_IN_THIS_STMT (stmt) = 1;
}
static void
insert_phi_nodes (bitmap *dfs)
{
- unsigned i;
+ referenced_var_iterator rvi;
+ tree var;
timevar_push (TV_TREE_INSERT_PHI_NODES);
-
- for (i = 0; i < num_referenced_vars; i++)
+
+ FOR_EACH_REFERENCED_VAR (var, rvi)
{
struct def_blocks_d *def_map;
bitmap idf;
- tree var = referenced_var (i);
def_map = find_def_blocks_for (var);
if (def_map == NULL)
static void
mark_def_site_blocks (sbitmap interesting_blocks)
{
- size_t i;
struct dom_walk_data walk_data;
struct mark_def_sites_global_data mark_def_sites_global_data;
+ referenced_var_iterator rvi;
+ tree var;
/* Allocate memory for the DEF_BLOCKS hash table. */
- def_blocks = htab_create (VEC_length (tree, referenced_vars),
+ def_blocks = htab_create (num_referenced_vars,
def_blocks_hash, def_blocks_eq, def_blocks_free);
-
- for (i = 0; i < num_referenced_vars; i++)
- set_current_def (referenced_var (i), NULL_TREE);
+ FOR_EACH_REFERENCED_VAR(var, rvi)
+ set_current_def (var, NULL_TREE);
/* Setup callbacks for the generic dominator tree walker to find and
mark definition sites. */
if (need_to_initialize_update_ssa_p)
init_update_ssa ();
- bitmap_set_bit (syms_to_rename, var_ann (sym)->uid);
+ bitmap_set_bit (syms_to_rename, DECL_UID (sym));
if (!is_gimple_reg (sym))
need_to_update_vops_p = true;
EXECUTE_IF_SET_IN_BITMAP (syms_to_rename, 0, i, bi)
insert_updated_phi_nodes_for (referenced_var (i), dfs, blocks,
- update_flags);
+ update_flags);
FOR_EACH_BB (bb)
BITMAP_FREE (dfs[bb->index]);
static bool
is_sra_candidate_decl (tree decl)
{
- return DECL_P (decl) && bitmap_bit_p (sra_candidates, var_ann (decl)->uid);
+ return DECL_P (decl) && bitmap_bit_p (sra_candidates, DECL_UID (decl));
}
/* Return true if TYPE is a scalar type. */
if (TREE_CODE (child) == PARM_DECL)
{
elt->n_copies = 1;
- bitmap_set_bit (needs_copy_in, var_ann (child)->uid);
+ bitmap_set_bit (needs_copy_in, DECL_UID (child));
}
}
static bool
find_candidates_for_sra (void)
{
- size_t i;
bool any_set = false;
+ tree var;
+ referenced_var_iterator rvi;
- for (i = 0; i < num_referenced_vars; i++)
+ FOR_EACH_REFERENCED_VAR (var, rvi)
{
- tree var = referenced_var (i);
if (decl_can_be_decomposed_p (var))
{
- bitmap_set_bit (sra_candidates, var_ann (var)->uid);
+ bitmap_set_bit (sra_candidates, DECL_UID (var));
any_set = true;
}
}
#include "convert.h"
#include "params.h"
#include "vec.h"
+#include "bitmap.h"
+
+/* Keep track of how many times each pointer has been dereferenced in
+ the program using the aux variable. This is used by the alias
+ grouping heuristic in compute_flow_insensitive_aliasing. */
+#define NUM_REFERENCES(ANN) ((size_t)((ANN)->common.aux))
+#define NUM_REFERENCES_CLEAR(ANN) ((ANN)->common.aux) = 0
+#define NUM_REFERENCES_INC(ANN) (ANN)->common.aux = (void*) (((size_t)((ANN)->common.aux)) + 1)
+#define NUM_REFERENCES_SET(ANN, VAL) (ANN)->common.aux = (void*) ((void *)(VAL))
+
+/* Obstack used to hold grouping bitmaps and other temporary bitmaps used by
+ aliasing */
+static bitmap_obstack alias_obstack;
/* 'true' after aliases have been computed (see compute_may_aliases). */
bool aliases_computed_p;
/* Set of variables aliased with VAR. This is the exact same
information contained in VAR_ANN (VAR)->MAY_ALIASES, but in
bitmap form to speed up alias grouping. */
- sbitmap may_aliases;
+ bitmap may_aliases;
};
/* Number of const/pure function calls found in the program. */
size_t num_pure_const_calls_found;
- /* Array of counters to keep track of how many times each pointer has
- been dereferenced in the program. This is used by the alias grouping
- heuristic in compute_flow_insensitive_aliasing. */
- varray_type num_references;
-
/* Total number of virtual operands that will be needed to represent
all the aliases of all the pointers found in the program. */
long total_alias_vops;
init_alias_info (void)
{
struct alias_info *ai;
+ referenced_var_iterator rvi;
+ tree var;
+ bitmap_obstack_initialize (&alias_obstack);
ai = xcalloc (1, sizeof (struct alias_info));
ai->ssa_names_visited = sbitmap_alloc (num_ssa_names);
sbitmap_zero (ai->ssa_names_visited);
VARRAY_TREE_INIT (ai->processed_ptrs, 50, "processed_ptrs");
- ai->addresses_needed = BITMAP_ALLOC (NULL);
- VARRAY_UINT_INIT (ai->num_references, num_referenced_vars, "num_references");
- ai->written_vars = BITMAP_ALLOC (NULL);
- ai->dereferenced_ptrs_store = BITMAP_ALLOC (NULL);
- ai->dereferenced_ptrs_load = BITMAP_ALLOC (NULL);
+ ai->addresses_needed = BITMAP_ALLOC (&alias_obstack);
+ ai->written_vars = BITMAP_ALLOC (&alias_obstack);
+ ai->dereferenced_ptrs_store = BITMAP_ALLOC (&alias_obstack);
+ ai->dereferenced_ptrs_load = BITMAP_ALLOC (&alias_obstack);
/* If aliases have been computed before, clear existing information. */
if (aliases_computed_p)
bitmap_clear (addressable_vars);
/* Clear flow-insensitive alias information from each symbol. */
- for (i = 0; i < num_referenced_vars; i++)
+ FOR_EACH_REFERENCED_VAR (var, rvi)
{
- tree var = referenced_var (i);
var_ann_t ann = var_ann (var);
-
+
ann->is_alias_tag = 0;
ann->may_aliases = NULL;
+ NUM_REFERENCES_CLEAR (ann);
/* Since we are about to re-discover call-clobbered
variables, clear the call-clobbered flag. Variables that
delete_alias_info (struct alias_info *ai)
{
size_t i;
+ referenced_var_iterator rvi;
+ tree var;
sbitmap_free (ai->ssa_names_visited);
ai->processed_ptrs = NULL;
BITMAP_FREE (ai->addresses_needed);
for (i = 0; i < ai->num_addressable_vars; i++)
+ free (ai->addressable_vars[i]);
+
+ FOR_EACH_REFERENCED_VAR(var, rvi)
{
- sbitmap_free (ai->addressable_vars[i]->may_aliases);
- free (ai->addressable_vars[i]);
+ var_ann_t ann = var_ann (var);
+ NUM_REFERENCES_CLEAR (ann);
}
+
free (ai->addressable_vars);
for (i = 0; i < ai->num_pointers; i++)
- {
- sbitmap_free (ai->pointers[i]->may_aliases);
- free (ai->pointers[i]);
- }
+ free (ai->pointers[i]);
free (ai->pointers);
- ai->num_references = NULL;
BITMAP_FREE (ai->written_vars);
BITMAP_FREE (ai->dereferenced_ptrs_store);
BITMAP_FREE (ai->dereferenced_ptrs_load);
+ bitmap_obstack_release (&alias_obstack);
free (ai);
}
}
}
-
/* Traverse use-def links for all the pointers in the program to collect
address escape and points-to information.
chains). */
addr_taken = addresses_taken (stmt);
if (addr_taken)
- EXECUTE_IF_SET_IN_BITMAP (addr_taken, 0, i, bi)
+ EXECUTE_IF_SET_IN_BITMAP (addr_taken, 0, i, bi)
{
tree var = referenced_var (i);
- bitmap_set_bit (ai->addresses_needed, var_ann (var)->uid);
+ bitmap_set_bit (ai->addresses_needed, DECL_UID (var));
if (stmt_escapes_p)
mark_call_clobbered (var);
}
FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_USE)
{
- var_ann_t v_ann = var_ann (SSA_NAME_VAR (op));
+ tree var = SSA_NAME_VAR (op);
+ var_ann_t v_ann = var_ann (var);
struct ptr_info_def *pi;
bool is_store;
unsigned num_uses, num_derefs;
because we are processing regular variables, not
memory tags (the array's initial size is set to
NUM_REFERENCED_VARS). */
- if (may_be_aliased (SSA_NAME_VAR (op)))
- (VARRAY_UINT (ai->num_references, v_ann->uid))++;
+ if (may_be_aliased (var))
+ NUM_REFERENCES_INC (v_ann);
if (!POINTER_TYPE_P (TREE_TYPE (op)))
continue;
pi->is_dereferenced = 1;
/* Keep track of how many time we've dereferenced each
- pointer. Again, we don't need to grow
- AI->NUM_REFERENCES because we're processing
- existing program variables. */
- (VARRAY_UINT (ai->num_references, v_ann->uid))++;
+ pointer. */
+ NUM_REFERENCES_INC (v_ann);
/* If this is a store operation, mark OP as being
dereferenced to store, otherwise mark it as being
dereferenced to load. */
if (is_store)
- bitmap_set_bit (ai->dereferenced_ptrs_store, v_ann->uid);
+ bitmap_set_bit (ai->dereferenced_ptrs_store,
+ DECL_UID (var));
else
- bitmap_set_bit (ai->dereferenced_ptrs_load, v_ann->uid);
+ bitmap_set_bit (ai->dereferenced_ptrs_load,
+ DECL_UID (var));
}
if (stmt_escapes_p && num_derefs < num_uses)
operation inside the called function. */
if (get_call_expr_in (stmt))
{
- bitmap_set_bit (ai->dereferenced_ptrs_store, v_ann->uid);
+ bitmap_set_bit (ai->dereferenced_ptrs_store,
+ DECL_UID (var));
pi->is_dereferenced = 1;
}
}
{
tree var = SSA_NAME_VAR (op);
var_ann_t ann = var_ann (var);
- bitmap_set_bit (ai->written_vars, ann->uid);
+ bitmap_set_bit (ai->written_vars, DECL_UID (var));
if (may_be_aliased (var))
- (VARRAY_UINT (ai->num_references, ann->uid))++;
+ NUM_REFERENCES_INC (ann);
if (POINTER_TYPE_P (TREE_TYPE (op)))
collect_points_to_info_for (ai, op);
FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_VIRTUAL_DEFS)
{
tree var = DECL_P (op) ? op : SSA_NAME_VAR (op);
- var_ann_t ann = var_ann (var);
- bitmap_set_bit (ai->written_vars, ann->uid);
+ bitmap_set_bit (ai->written_vars, DECL_UID (var));
}
/* After promoting variables and computing aliasing we will
}
-
/* For every pointer P_i in AI->PROCESSED_PTRS, create may-alias sets for
the name memory tag (NMT) associated with P_i. If P_i escapes, then its
name tag and the variables it points-to are call-clobbered. Finally, if
var_ann_t tag_ann = var_ann (tag);
p_map->total_alias_vops = 0;
- p_map->may_aliases = sbitmap_alloc (num_referenced_vars);
- sbitmap_zero (p_map->may_aliases);
+ p_map->may_aliases = BITMAP_ALLOC (&alias_obstack);
for (j = 0; j < ai->num_addressable_vars; j++)
{
So we first check the call_clobbered status of the
tag and variable before querying the bitmap. */
tag_stored_p = is_call_clobbered (tag)
- || bitmap_bit_p (ai->written_vars, tag_ann->uid);
+ || bitmap_bit_p (ai->written_vars, DECL_UID (tag));
var_stored_p = is_call_clobbered (var)
- || bitmap_bit_p (ai->written_vars, v_ann->uid);
+ || bitmap_bit_p (ai->written_vars, DECL_UID (var));
if (!tag_stored_p && !var_stored_p)
continue;
subvar_t svars;
size_t num_tag_refs, num_var_refs;
- num_tag_refs = VARRAY_UINT (ai->num_references, tag_ann->uid);
- num_var_refs = VARRAY_UINT (ai->num_references, v_ann->uid);
+ num_tag_refs = NUM_REFERENCES (tag_ann);
+ num_var_refs = NUM_REFERENCES (v_ann);
/* Add VAR to TAG's may-aliases set. */
add_may_alias (tag, sv->var);
/* Update the bitmap used to represent TAG's alias set
in case we need to group aliases. */
- SET_BIT (p_map->may_aliases, var_ann (sv->var)->uid);
+ bitmap_set_bit (p_map->may_aliases, DECL_UID (sv->var));
}
}
else
add_may_alias (tag, var);
/* Update the bitmap used to represent TAG's alias set
in case we need to group aliases. */
- SET_BIT (p_map->may_aliases, var_ann (var)->uid);
+ bitmap_set_bit (p_map->may_aliases, DECL_UID (var));
}
/* Update the total number of virtual operands due to
size_t j;
struct alias_map_d *p_map1 = ai->pointers[i];
tree tag1 = var_ann (p_map1->var)->type_mem_tag;
- sbitmap may_aliases1 = p_map1->may_aliases;
+ bitmap may_aliases1 = p_map1->may_aliases;
for (j = i + 1; j < ai->num_pointers; j++)
{
struct alias_map_d *p_map2 = ai->pointers[j];
tree tag2 = var_ann (p_map2->var)->type_mem_tag;
- sbitmap may_aliases2 = p_map2->may_aliases;
+ bitmap may_aliases2 = p_map2->may_aliases;
/* If the pointers may not point to each other, do nothing. */
if (!may_alias_p (p_map1->var, p_map1->set, tag2, p_map2->set))
/* The two pointers may alias each other. If they already have
symbols in common, do nothing. */
- if (sbitmap_any_common_bits (may_aliases1, may_aliases2))
+ if (bitmap_intersect_p (may_aliases1, may_aliases2))
continue;
- if (sbitmap_first_set_bit (may_aliases2) >= 0)
+ if (!bitmap_empty_p (may_aliases2))
{
unsigned int k;
- sbitmap_iterator sbi;
+ bitmap_iterator bi;
/* Add all the aliases for TAG2 into TAG1's alias set.
FIXME, update grouping heuristic counters. */
- EXECUTE_IF_SET_IN_SBITMAP (may_aliases2, 0, k, sbi)
+ EXECUTE_IF_SET_IN_BITMAP (may_aliases2, 0, k, bi)
add_may_alias (tag1, referenced_var (k));
- sbitmap_a_or_b (may_aliases1, may_aliases1, may_aliases2);
+ bitmap_ior_into (may_aliases1, may_aliases2);
}
else
{
/* Since TAG2 does not have any aliases of its own, add
TAG2 itself to the alias set of TAG1. */
add_may_alias (tag1, tag2);
- SET_BIT (may_aliases1, var_ann (tag2)->uid);
+ bitmap_set_bit (may_aliases1, DECL_UID (tag2));
}
}
}
-
+
if (dump_file)
fprintf (dump_file, "%s: Total number of aliased vops: %ld\n",
get_name (current_function_decl),
may-aliases(V2) = { TAG } */
static void
-group_aliases_into (tree tag, sbitmap tag_aliases, struct alias_info *ai)
+group_aliases_into (tree tag, bitmap tag_aliases, struct alias_info *ai)
{
unsigned int i;
var_ann_t tag_ann = var_ann (tag);
- size_t num_tag_refs = VARRAY_UINT (ai->num_references, tag_ann->uid);
- sbitmap_iterator sbi;
+ size_t num_tag_refs = NUM_REFERENCES (tag_ann);
+ bitmap_iterator bi;
- EXECUTE_IF_SET_IN_SBITMAP (tag_aliases, 0, i, sbi)
+ EXECUTE_IF_SET_IN_BITMAP (tag_aliases, 0, i, bi)
{
tree var = referenced_var (i);
var_ann_t ann = var_ann (var);
{
size_t j;
tree tag1 = var_ann (ai->pointers[i]->var)->type_mem_tag;
- sbitmap tag1_aliases = ai->pointers[i]->may_aliases;
+ bitmap tag1_aliases = ai->pointers[i]->may_aliases;
/* Skip tags that have been grouped already. */
if (ai->pointers[i]->grouped_p)
aliases into TAG1. */
for (j = i + 1; j < ai->num_pointers; j++)
{
- sbitmap tag2_aliases = ai->pointers[j]->may_aliases;
+ bitmap tag2_aliases = ai->pointers[j]->may_aliases;
- if (sbitmap_any_common_bits (tag1_aliases, tag2_aliases))
+ if (bitmap_intersect_p (tag1_aliases, tag2_aliases))
{
tree tag2 = var_ann (ai->pointers[j]->var)->type_mem_tag;
- sbitmap_a_or_b (tag1_aliases, tag1_aliases, tag2_aliases);
+ bitmap_ior_into (tag1_aliases, tag2_aliases);
/* TAG2 does not need its aliases anymore. */
- sbitmap_zero (tag2_aliases);
+ bitmap_clear (tag2_aliases);
var_ann (tag2)->may_aliases = NULL;
/* TAG1 is the unique alias of TAG2. */
static void
setup_pointers_and_addressables (struct alias_info *ai)
{
- size_t i, n_vars, num_addressable_vars, num_pointers;
+ size_t n_vars, num_addressable_vars, num_pointers;
+ referenced_var_iterator rvi;
+ tree var;
/* Size up the arrays ADDRESSABLE_VARS and POINTERS. */
num_addressable_vars = num_pointers = 0;
- for (i = 0; i < num_referenced_vars; i++)
+
+ FOR_EACH_REFERENCED_VAR (var, rvi)
{
- tree var = referenced_var (i);
-
if (may_be_aliased (var))
num_addressable_vars++;
/* Since we don't keep track of volatile variables, assume that
these pointers are used in indirect store operations. */
if (TREE_THIS_VOLATILE (var))
- bitmap_set_bit (ai->dereferenced_ptrs_store, var_ann (var)->uid);
+ bitmap_set_bit (ai->dereferenced_ptrs_store, DECL_UID (var));
num_pointers++;
}
unnecessarily. */
n_vars = num_referenced_vars;
- for (i = 0; i < n_vars; i++)
+ FOR_EACH_REFERENCED_VAR (var, rvi)
{
- tree var = referenced_var (i);
var_ann_t v_ann = var_ann (var);
subvar_t svars;
cleanup passes. */
if (TREE_ADDRESSABLE (var) && v_ann->mem_tag_kind != STRUCT_FIELD)
{
- if (!bitmap_bit_p (ai->addresses_needed, v_ann->uid)
+ if (!bitmap_bit_p (ai->addresses_needed, DECL_UID (var))
&& TREE_CODE (var) != RESULT_DECL
&& !is_global_var (var))
{
for (sv = svars; sv; sv = sv->next)
{
- var_ann_t svann = var_ann (sv->var);
- if (bitmap_bit_p (ai->addresses_needed, svann->uid))
+ if (bitmap_bit_p (ai->addresses_needed,
+ DECL_UID (sv->var)))
okay_to_mark = false;
mark_sym_for_renaming (sv->var);
}
used when scanning operands for ASM_EXPRs that
clobber memory. In those cases, we need to clobber
all call-clobbered variables and all addressables. */
- bitmap_set_bit (addressable_vars, v_ann->uid);
+ bitmap_set_bit (addressable_vars, DECL_UID (var));
if (var_can_have_subvars (var)
&& (svars = get_subvars_for_var (var)))
{
subvar_t sv;
for (sv = svars; sv; sv = sv->next)
- bitmap_set_bit (addressable_vars, var_ann (sv->var)->uid);
+ bitmap_set_bit (addressable_vars, DECL_UID (sv->var));
}
}
array and create a type memory tag for them. */
if (POINTER_TYPE_P (TREE_TYPE (var)))
{
- if ((bitmap_bit_p (ai->dereferenced_ptrs_store, v_ann->uid)
- || bitmap_bit_p (ai->dereferenced_ptrs_load, v_ann->uid)))
+ if ((bitmap_bit_p (ai->dereferenced_ptrs_store, DECL_UID (var))
+ || bitmap_bit_p (ai->dereferenced_ptrs_load, DECL_UID (var))))
{
tree tag;
var_ann_t t_ann;
/* If pointer VAR has been used in a store operation,
then its memory tag must be marked as written-to. */
- if (bitmap_bit_p (ai->dereferenced_ptrs_store, v_ann->uid))
- bitmap_set_bit (ai->written_vars, t_ann->uid);
+ if (bitmap_bit_p (ai->dereferenced_ptrs_store, DECL_UID (var)))
+ bitmap_set_bit (ai->written_vars, DECL_UID (tag));
/* If pointer VAR is a global variable or a PARM_DECL,
then its memory tag should be considered a global
/* All the dereferences of pointer VAR count as
references of TAG. Since TAG can be associated with
several pointers, add the dereferences of VAR to the
- TAG. We may need to grow AI->NUM_REFERENCES because
- we have been adding name and type tags. */
- if (t_ann->uid >= VARRAY_SIZE (ai->num_references))
- VARRAY_GROW (ai->num_references, t_ann->uid + 10);
+ TAG. */
- VARRAY_UINT (ai->num_references, t_ann->uid)
- += VARRAY_UINT (ai->num_references, v_ann->uid);
+ NUM_REFERENCES_SET (t_ann,
+ NUM_REFERENCES (t_ann) +
+ NUM_REFERENCES (v_ann));
}
else
{
/* Mark all call-clobbered symbols for renaming. Since the initial
rewrite into SSA ignored all call sites, we may need to rename
- .GLOBAL_VAR and the call-clobbered variables. */
+ .GLOBAL_VAR and the call-clobbered variables. */
EXECUTE_IF_SET_IN_BITMAP (call_clobbered_vars, 0, i, bi)
{
tree var = referenced_var (i);
subvar_t sv;
svars = get_subvars_for_var (ref);
- uid = var_ann (pt_var)->uid;
+ uid = DECL_UID (pt_var);
if (pi->pt_vars == NULL)
pi->pt_vars = BITMAP_GGC_ALLOC ();
{
if (overlap_subvar (offset, size, sv, NULL))
{
- bitmap_set_bit (pi->pt_vars, var_ann (sv->var)->uid);
- bitmap_set_bit (ai->addresses_needed, var_ann (sv->var)->uid);
+ bitmap_set_bit (pi->pt_vars, DECL_UID (sv->var));
+ bitmap_set_bit (ai->addresses_needed, DECL_UID (sv->var));
}
}
}
else if (pt_var && SSA_VAR_P (pt_var))
{
- uid = var_ann (pt_var)->uid;
+ uid = DECL_UID (pt_var);
if (pi->pt_vars == NULL)
pi->pt_vars = BITMAP_GGC_ALLOC ();
subvar_t sv;
for (sv = svars; sv; sv = sv->next)
{
- uid = var_ann (sv->var)->uid;
+ uid = DECL_UID (sv->var);
bitmap_set_bit (ai->addresses_needed, uid);
bitmap_set_bit (pi->pt_vars, uid);
}
size_t i;
const char *funcname
= lang_hooks.decl_printable_name (current_function_decl, 2);
+ referenced_var_iterator rvi;
+ tree var;
fprintf (file, "\nFlow-insensitive alias information for %s\n\n", funcname);
fprintf (file, "Aliased symbols\n\n");
- for (i = 0; i < num_referenced_vars; i++)
+
+ FOR_EACH_REFERENCED_VAR (var, rvi)
{
- tree var = referenced_var (i);
if (may_be_aliased (var))
dump_variable (file, var);
}
fprintf (file, "\nDereferenced pointers\n\n");
- for (i = 0; i < num_referenced_vars; i++)
+
+ FOR_EACH_REFERENCED_VAR (var, rvi)
{
- tree var = referenced_var (i);
var_ann_t ann = var_ann (var);
if (ann->type_mem_tag)
dump_variable (file, var);
}
fprintf (file, "\nType memory tags\n\n");
- for (i = 0; i < num_referenced_vars; i++)
+
+ FOR_EACH_REFERENCED_VAR (var, rvi)
{
- tree var = referenced_var (i);
var_ann_t ann = var_ann (var);
if (ann->mem_tag_kind == TYPE_TAG)
dump_variable (file, var);
}
fprintf (file, "\nName memory tags\n\n");
- for (i = 0; i < num_referenced_vars; i++)
+
+ FOR_EACH_REFERENCED_VAR (var, rvi)
{
- tree var = referenced_var (i);
var_ann_t ann = var_ann (var);
if (ann->mem_tag_kind == NAME_TAG)
dump_variable (file, var);
{
basic_block bb;
block_stmt_iterator si;
- size_t i;
ssa_op_iter iter;
const char *fname =
lang_hooks.decl_printable_name (current_function_decl, 2);
+ referenced_var_iterator rvi;
+ tree var;
fprintf (file, "\n\nPointed-to sets for pointers in %s\n\n", fname);
/* First dump points-to information for the default definitions of
pointer variables. This is necessary because default definitions are
not part of the code. */
- for (i = 0; i < num_referenced_vars; i++)
+ FOR_EACH_REFERENCED_VAR (var, rvi)
{
- tree var = referenced_var (i);
if (POINTER_TYPE_P (TREE_TYPE (var)))
{
var_ann_t ann = var_ann (var);
tree tag;
var_ann_t ann = var_ann (ptr);
subvar_t svars;
+
if (ann->type_mem_tag == NULL_TREE)
{
- size_t i;
tree q = NULL_TREE;
tree tag_type = TREE_TYPE (TREE_TYPE (ptr));
HOST_WIDE_INT tag_set = get_alias_set (tag_type);
+ referenced_var_iterator rvi;
/* PTR doesn't have a type tag, create a new one and add VAR to
the new tag's alias set.
whether there is another pointer Q with the same alias set as
PTR. This could be sped up by having type tags associated
with types. */
- for (i = 0; i < num_referenced_vars; i++)
+ FOR_EACH_REFERENCED_VAR (q, rvi)
{
- q = referenced_var (i);
-
if (POINTER_TYPE_P (TREE_TYPE (q))
&& tag_set == get_alias_set (TREE_TYPE (TREE_TYPE (q))))
{
}
}
+
+
/* This represents the used range of a variable. */
typedef struct used_part
/* An array of used_part structures, indexed by variable uid. */
-static used_part_t *used_portions;
+static htab_t used_portions;
+
+struct used_part_map
+{
+ unsigned int uid;
+ used_part_t to;
+};
+
+/* Return true if the uid in the two used part maps are equal. */
+
+static int
+used_part_map_eq (const void *va, const void *vb)
+{
+ const struct used_part_map *a = va, *b = vb;
+ return (a->uid == b->uid);
+}
+
+/* Hash a from uid in a used_part_map. */
+
+static unsigned int
+used_part_map_hash (const void *item)
+{
+ return ((const struct used_part_map *)item)->uid;
+}
+
+/* Free a used part map element. */
+
+static void
+free_used_part_map (void *item)
+{
+ free (((struct used_part_map *)item)->to);
+}
+
+/* Lookup a used_part structure for a UID. */
+
+static used_part_t
+up_lookup (unsigned int uid)
+{
+ struct used_part_map *h, in;
+ in.uid = uid;
+ h = htab_find_with_hash (used_portions, &in, uid);
+ if (!h)
+ return NULL;
+ return h->to;
+}
+
+/* Insert the pair UID, TO into the used part hashtable. */
+
+static void
+up_insert (unsigned int uid, used_part_t to)
+{
+ struct used_part_map *h;
+ void **loc;
+
+ h = xmalloc (sizeof (struct used_part_map));
+ h->uid = uid;
+ h->to = to;
+ loc = htab_find_slot_with_hash (used_portions, h,
+ uid, INSERT);
+ *(struct used_part_map **) loc = h;
+}
+
/* Given a variable uid, UID, get or create the entry in the used portions
table for the variable. */
get_or_create_used_part_for (size_t uid)
{
used_part_t up;
- if (used_portions[uid] == NULL)
+ if ((up = up_lookup (uid)) == NULL)
{
up = xcalloc (1, sizeof (struct used_part));
up->minused = INT_MAX;
up->explicit_uses = false;
up->implicit_uses = false;
}
- else
- up = used_portions[uid];
+
return up;
}
{
VEC(fieldoff_s,heap) *fieldstack = NULL;
used_part_t up;
- size_t uid = var_ann (var)->uid;
+ size_t uid = DECL_UID (var);
- if (used_portions[uid] == NULL)
+ if (!up_lookup (uid))
return;
- up = used_portions[uid];
+ up = up_lookup (uid);
push_fields_onto_fieldstack (TREE_TYPE (var), &fieldstack, 0, NULL);
if (VEC_length (fieldoff_s, fieldstack) != 0)
{
&unsignedp, &volatilep, false);
if (DECL_P (ref) && offset == NULL && bitsize != -1)
{
- size_t uid = var_ann (ref)->uid;
+ size_t uid = DECL_UID (ref);
used_part_t up;
up = get_or_create_used_part_for (uid);
up->maxused = bitpos + bitsize;
up->explicit_uses = true;
- used_portions[uid] = up;
+ up_insert (uid, up);
*walk_subtrees = 0;
return NULL_TREE;
&& TREE_CODE (DECL_SIZE (ref)) == INTEGER_CST)
{
used_part_t up;
- size_t uid = var_ann (ref)->uid;
+ size_t uid = DECL_UID (ref);
up = get_or_create_used_part_for (uid);
up->implicit_uses = true;
- used_portions[uid] = up;
+ up_insert (uid, up);
*walk_subtrees = 0;
return NULL_TREE;
&& TREE_CODE (DECL_SIZE (var)) == INTEGER_CST)
{
used_part_t up;
- size_t uid = var_ann (var)->uid;
+ size_t uid = DECL_UID (var);
up = get_or_create_used_part_for (uid);
up->maxused = TREE_INT_CST_LOW (DECL_SIZE (var));
up->implicit_uses = true;
- used_portions[uid] = up;
+ up_insert (uid, up);
*walk_subtrees = 0;
return NULL_TREE;
}
&& TREE_CODE (DECL_SIZE (var)) == INTEGER_CST)
{
used_part_t up;
- size_t uid = var_ann (var)->uid;
+ size_t uid = DECL_UID (var);
up = get_or_create_used_part_for (uid);
up->maxused = TREE_INT_CST_LOW (DECL_SIZE (var));
up->implicit_uses = true;
- used_portions[uid] = up;
+ up_insert (uid, up);
*walk_subtrees = 0;
return NULL_TREE;
}
return NULL_TREE;
}
-/* We are about to create some new referenced variables, and we need the
- before size. */
-
-static size_t old_referenced_vars;
-
-
/* Create structure field variables for structures used in this function. */
static void
create_structure_vars (void)
{
basic_block bb;
- size_t i;
+ referenced_var_iterator rvi;
+ tree var;
- old_referenced_vars = num_referenced_vars;
- used_portions = xcalloc (num_referenced_vars, sizeof (used_part_t));
+ used_portions = htab_create (10, used_part_map_hash, used_part_map_eq,
+ free_used_part_map);
FOR_EACH_BB (bb)
{
NULL);
}
}
- for (i = 0; i < old_referenced_vars; i++)
+ FOR_EACH_REFERENCED_VAR (var, rvi)
{
- tree var = referenced_var (i);
/* The C++ FE creates vars without DECL_SIZE set, for some reason. */
if (var
&& DECL_SIZE (var)
&& TREE_CODE (DECL_SIZE (var)) == INTEGER_CST)
create_overlap_variables_for (var);
}
- for (i = 0; i < old_referenced_vars; i++)
- free (used_portions[i]);
+ htab_delete (used_portions);
- free (used_portions);
}
static bool
var_map map;
ssa_op_iter iter;
#ifdef ENABLE_CHECKING
- sbitmap used_in_real_ops;
- sbitmap used_in_virtual_ops;
+ bitmap used_in_real_ops;
+ bitmap used_in_virtual_ops;
#endif
map = init_var_map (num_ssa_names + 1);
#ifdef ENABLE_CHECKING
- used_in_real_ops = sbitmap_alloc (num_referenced_vars);
- sbitmap_zero (used_in_real_ops);
-
- used_in_virtual_ops = sbitmap_alloc (num_referenced_vars);
- sbitmap_zero (used_in_virtual_ops);
+ used_in_real_ops = BITMAP_ALLOC (NULL);
+ used_in_virtual_ops = BITMAP_ALLOC (NULL);
#endif
if (flags & SSA_VAR_MAP_REF_COUNT)
register_ssa_partition (map, use, true);
#ifdef ENABLE_CHECKING
- SET_BIT (used_in_real_ops, var_ann (SSA_NAME_VAR (use))->uid);
+ bitmap_set_bit (used_in_real_ops, DECL_UID (SSA_NAME_VAR (use)));
#endif
}
register_ssa_partition (map, dest, false);
#ifdef ENABLE_CHECKING
- SET_BIT (used_in_real_ops, var_ann (SSA_NAME_VAR (dest))->uid);
+ bitmap_set_bit (used_in_real_ops, DECL_UID (SSA_NAME_VAR (dest)));
#endif
}
FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter,
SSA_OP_VIRTUAL_USES | SSA_OP_VMUSTDEF)
{
- SET_BIT (used_in_virtual_ops, var_ann (SSA_NAME_VAR (use))->uid);
+ bitmap_set_bit (used_in_virtual_ops,
+ DECL_UID (SSA_NAME_VAR (use)));
}
#endif /* ENABLE_CHECKING */
#if defined ENABLE_CHECKING
{
unsigned i;
- sbitmap both = sbitmap_alloc (num_referenced_vars);
- sbitmap_a_and_b (both, used_in_real_ops, used_in_virtual_ops);
- if (sbitmap_first_set_bit (both) >= 0)
+ bitmap both = BITMAP_ALLOC (NULL);
+ bitmap_and (both, used_in_real_ops, used_in_virtual_ops);
+ if (!bitmap_empty_p (both))
{
- sbitmap_iterator sbi;
+ bitmap_iterator bi;
- EXECUTE_IF_SET_IN_SBITMAP (both, 0, i, sbi)
+ EXECUTE_IF_SET_IN_BITMAP (both, 0, i, bi)
fprintf (stderr, "Variable %s used in real and virtual operands\n",
get_name (referenced_var (i)));
internal_error ("SSA corruption");
}
- sbitmap_free (used_in_real_ops);
- sbitmap_free (used_in_virtual_ops);
- sbitmap_free (both);
+ BITMAP_FREE (used_in_real_ops);
+ BITMAP_FREE (used_in_virtual_ops);
+ BITMAP_FREE (both);
}
#endif
FOR_EACH_SSA_TREE_OPERAND (vname, stmt, oi,
SSA_OP_VIRTUAL_USES | SSA_OP_VIRTUAL_KILLS)
- {
- bitmap_set_bit (ref->vops,
- var_ann (SSA_NAME_VAR (vname))->uid);
- }
+ bitmap_set_bit (ref->vops, DECL_UID (SSA_NAME_VAR (vname)));
record_mem_ref_loc (&ref->locs, stmt, mem);
return;
fail:
FOR_EACH_SSA_TREE_OPERAND (vname, stmt, oi,
SSA_OP_VIRTUAL_USES | SSA_OP_VIRTUAL_KILLS)
- {
- bitmap_set_bit (clobbered_vops,
- var_ann (SSA_NAME_VAR (vname))->uid);
- }
+ bitmap_set_bit (clobbered_vops, DECL_UID (SSA_NAME_VAR (vname)));
}
/* Gathers memory references in LOOP. Notes vops accessed through unrecognized
add_stmt_operand (&global_var, s_ann, opf_is_def);
else
EXECUTE_IF_SET_IN_BITMAP (call_clobbered_vars, 0, i, bi)
- {
- tree var = referenced_var (i);
- add_stmt_operand (&var, s_ann, opf_is_def | opf_non_specific);
- }
+ {
+ tree var = referenced_var (i);
+ add_stmt_operand (&var, s_ann, opf_is_def | opf_non_specific);
+ }
/* Now clobber all addressables. */
EXECUTE_IF_SET_IN_BITMAP (addressable_vars, 0, i, bi)
{
subvar_t sv;
for (sv = svars; sv; sv = sv->next)
- bitmap_set_bit (s_ann->addresses_taken, var_ann (sv->var)->uid);
+ bitmap_set_bit (s_ann->addresses_taken, DECL_UID (sv->var));
}
else
- bitmap_set_bit (s_ann->addresses_taken, var_ann (var)->uid);
+ bitmap_set_bit (s_ann->addresses_taken, DECL_UID (var));
}
}
subvar_t svars = get_subvars_for_var (vi->decl);
subvar_t sv;
for (sv = svars; sv; sv = sv->next)
- bitmap_set_bit (into, var_ann (sv->var)->uid);
+ bitmap_set_bit (into, DECL_UID (sv->var));
}
/* We may end up with labels in the points-to set because people
take their address, and they are _DECL's. */
else if (TREE_CODE (vi->decl) == VAR_DECL
|| TREE_CODE (vi->decl) == PARM_DECL)
- bitmap_set_bit (into, var_ann (vi->decl)->uid);
+ bitmap_set_bit (into, DECL_UID (vi->decl));
}
static void
verify_flow_insensitive_alias_info (void)
{
- size_t i;
tree var;
bitmap visited = BITMAP_ALLOC (NULL);
+ referenced_var_iterator rvi;
- for (i = 0; i < num_referenced_vars; i++)
+ FOR_EACH_REFERENCED_VAR (var, rvi)
{
size_t j;
var_ann_t ann;
varray_type may_aliases;
- var = referenced_var (i);
ann = var_ann (var);
may_aliases = ann->may_aliases;
{
tree alias = VARRAY_TREE (may_aliases, j);
- bitmap_set_bit (visited, var_ann (alias)->uid);
+ bitmap_set_bit (visited, DECL_UID (alias));
if (!may_be_aliased (alias))
{
}
}
- for (i = 0; i < num_referenced_vars; i++)
+ FOR_EACH_REFERENCED_VAR (var, rvi)
{
var_ann_t ann;
-
- var = referenced_var (i);
ann = var_ann (var);
if (ann->mem_tag_kind == NOT_A_TAG
&& ann->is_alias_tag
- && !bitmap_bit_p (visited, ann->uid))
+ && !bitmap_bit_p (visited, DECL_UID (var)))
{
error ("Addressable variable that is an alias tag but is not in any alias set.");
goto err;
for (i = 0; aliases && i < VARRAY_ACTIVE_SIZE (aliases); i++)
{
tree alias = VARRAY_TREE (aliases, i);
- bitmap_set_bit (type_aliases, var_ann (alias)->uid);
+ bitmap_set_bit (type_aliases, DECL_UID (alias));
}
/* When grouping, we may have added PTR's type tag into the
alias set of PTR's name tag. To prevent a false
positive, pretend that TMT is in its own alias set. */
- bitmap_set_bit (type_aliases, var_ann (tmt)->uid);
+ bitmap_set_bit (type_aliases, DECL_UID (tmt));
if (bitmap_equal_p (type_aliases, pi->pt_vars))
continue;
internal_error ("verify_ssa failed.");
}
+/* Return true if the uid in both int tree maps are equal. */
+
+int
+int_tree_map_eq (const void *va, const void *vb)
+{
+ const struct int_tree_map *a = va, *b = vb;
+ return (a->uid == b->uid);
+}
+
+/* Hash a UID in a int_tree_map. */
+
+unsigned int
+int_tree_map_hash (const void *item)
+{
+ return ((const struct int_tree_map *)item)->uid;
+}
+
/* Initialize global DFA and SSA structures. */
void
init_tree_ssa (void)
{
- referenced_vars = VEC_alloc (tree, gc, 20);
+ referenced_vars = htab_create_ggc (20, int_tree_map_hash,
+ int_tree_map_eq, NULL);
call_clobbered_vars = BITMAP_ALLOC (NULL);
addressable_vars = BITMAP_ALLOC (NULL);
init_ssanames ();
size_t i;
basic_block bb;
block_stmt_iterator bsi;
+ referenced_var_iterator rvi;
+ tree var;
/* Release any ssa_names still in use. */
for (i = 0; i < num_ssa_names; i++)
}
/* Remove annotations from every referenced variable. */
- for (i = 0; i < num_referenced_vars; i++)
+ FOR_EACH_REFERENCED_VAR (var, rvi)
{
- tree var = referenced_var (i);
ggc_free (var->common.ann);
var->common.ann = NULL;
}
- VEC_free (tree, gc, referenced_vars);
+ htab_delete (referenced_vars);
+ referenced_vars = NULL;
fini_ssanames ();
fini_phinodes ();
var = SSA_NAME_VAR (var);
if (TREE_CODE (var) == VAR_DECL
- && bitmap_bit_p (va_list_vars, var_ann (var)->uid))
+ && bitmap_bit_p (va_list_vars, DECL_UID (var)))
return var;
return NULL_TREE;
return false;
if (TREE_CODE (var) != SSA_NAME
- || bitmap_bit_p (si->va_list_vars, var_ann (SSA_NAME_VAR (var))->uid))
+ || bitmap_bit_p (si->va_list_vars, DECL_UID (SSA_NAME_VAR (var))))
return false;
base = get_base_address (ap);
if (TREE_CODE (base) != VAR_DECL
- || !bitmap_bit_p (si->va_list_vars, var_ann (base)->uid))
+ || !bitmap_bit_p (si->va_list_vars, DECL_UID (base)))
return false;
if (TREE_OPERAND (ap, 1) == va_list_gpr_counter_field)
va_list_ptr_read (struct stdarg_info *si, tree ap, tree tem)
{
if (TREE_CODE (ap) != VAR_DECL
- || !bitmap_bit_p (si->va_list_vars, var_ann (ap)->uid))
+ || !bitmap_bit_p (si->va_list_vars, DECL_UID (ap)))
return false;
if (TREE_CODE (tem) != SSA_NAME
|| bitmap_bit_p (si->va_list_vars,
- var_ann (SSA_NAME_VAR (tem))->uid)
+ DECL_UID (SSA_NAME_VAR (tem)))
|| is_global_var (SSA_NAME_VAR (tem)))
return false;
/* Note the temporary, as we need to track whether it doesn't escape
the current function. */
bitmap_set_bit (si->va_list_escape_vars,
- var_ann (SSA_NAME_VAR (tem))->uid);
+ DECL_UID (SSA_NAME_VAR (tem)));
return true;
}
unsigned HOST_WIDE_INT increment;
if (TREE_CODE (ap) != VAR_DECL
- || !bitmap_bit_p (si->va_list_vars, var_ann (ap)->uid))
+ || !bitmap_bit_p (si->va_list_vars, DECL_UID (ap)))
return false;
if (TREE_CODE (tem2) != SSA_NAME
- || bitmap_bit_p (si->va_list_vars, var_ann (SSA_NAME_VAR (tem2))->uid))
+ || bitmap_bit_p (si->va_list_vars, DECL_UID (SSA_NAME_VAR (tem2))))
return false;
if (si->compute_sizes <= 0)
if (TREE_CODE (rhs) != SSA_NAME
|| ! bitmap_bit_p (si->va_list_escape_vars,
- var_ann (SSA_NAME_VAR (rhs))->uid))
+ DECL_UID (SSA_NAME_VAR (rhs))))
return;
if (TREE_CODE (lhs) != SSA_NAME || is_global_var (SSA_NAME_VAR (lhs)))
}
bitmap_set_bit (si->va_list_escape_vars,
- var_ann (SSA_NAME_VAR (lhs))->uid);
+ DECL_UID (SSA_NAME_VAR (lhs)));
}
FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_ALL_USES)
{
if (! bitmap_bit_p (si->va_list_escape_vars,
- var_ann (SSA_NAME_VAR (use))->uid))
+ DECL_UID (SSA_NAME_VAR (use))))
continue;
if (TREE_CODE (stmt) == MODIFY_EXPR)
{
if (TREE_CODE (lhs) == SSA_NAME
&& bitmap_bit_p (si->va_list_escape_vars,
- var_ann (SSA_NAME_VAR (lhs))->uid))
+ DECL_UID (SSA_NAME_VAR (lhs))))
continue;
if (TREE_CODE (lhs) == VAR_DECL
&& bitmap_bit_p (si->va_list_vars,
- var_ann (lhs)->uid))
+ DECL_UID (lhs)))
continue;
}
}
break;
}
- bitmap_set_bit (si.va_list_vars, var_ann (ap)->uid);
+ bitmap_set_bit (si.va_list_vars, DECL_UID (ap));
/* VA_START_BB and VA_START_AP will be only used if there is just
one va_start in the function. */
static bool
suitable_for_tail_opt_p (void)
{
- int i;
+ referenced_var_iterator rvi;
+ tree var;
if (current_function_stdarg)
return false;
/* No local variable nor structure field should be call-clobbered. We
ignore any kind of memory tag, as these are not real variables. */
- for (i = 0; i < (int) num_referenced_vars; i++)
+
+ FOR_EACH_REFERENCED_VAR (var, rvi)
{
- tree var = VEC_index (tree, referenced_vars, i);
if (!(TREE_STATIC (var) || DECL_EXTERNAL (var))
&& (var_ann (var)->mem_tag_kind == NOT_A_TAG
+2005-06-30 Daniel Berlin <dberlin@dberlin.org>
+
+ * hashtab.h (HTAB_DELETED_ENTRY): New macro.
+ (HTAB_EMPTY_ENTRY): New macro.
+
2005-06-20 Geoffrey Keating <geoffk@apple.com>
* libiberty.h (strverscmp): Prototype.
typedef void *(*htab_alloc_with_arg) (void *, size_t, size_t);
typedef void (*htab_free_with_arg) (void *, void *);
+/* This macro defines reserved value for empty table entry. */
+
+#define HTAB_EMPTY_ENTRY ((PTR) 0)
+
+/* This macro defines reserved value for table entry which contained
+ a deleted element. */
+
+#define HTAB_DELETED_ENTRY ((PTR) 1)
+
/* Hash tables are of the following type. The structure
(implementation) of this type is not needed for using the hash
tables. All work with hash table should be executed only through
+2005-06-30 Daniel Berlin <dberlin@dberlin.org>
+
+ * hashtab.c (EMPTY_ENTRY): Moved and renamed.
+ (DELETED_ENTRY): Ditto.
+
2005-06-20 Geoffrey Keating <geoffk@apple.com>
* strverscmp.c: New.
#define CHAR_BIT 8
#endif
-/* This macro defines reserved value for empty table entry. */
-
-#define EMPTY_ENTRY ((PTR) 0)
-
-/* This macro defines reserved value for table entry which contained
- a deleted element. */
-
-#define DELETED_ENTRY ((PTR) 1)
-
static unsigned int higher_prime_index (unsigned long);
static hashval_t htab_mod_1 (hashval_t, hashval_t, hashval_t, int);
static hashval_t htab_mod (hashval_t, htab_t);
/* This function creates table with length slightly longer than given
source length. Created hash table is initiated as empty (all the
- hash table entries are EMPTY_ENTRY). The function returns the
+ hash table entries are HTAB_EMPTY_ENTRY). The function returns the
created hash table, or NULL if memory allocation fails. */
htab_t
if (htab->del_f)
for (i = size - 1; i >= 0; i--)
- if (entries[i] != EMPTY_ENTRY && entries[i] != DELETED_ENTRY)
+ if (entries[i] != HTAB_EMPTY_ENTRY && entries[i] != HTAB_DELETED_ENTRY)
(*htab->del_f) (entries[i]);
if (htab->free_f != NULL)
if (htab->del_f)
for (i = size - 1; i >= 0; i--)
- if (entries[i] != EMPTY_ENTRY && entries[i] != DELETED_ENTRY)
+ if (entries[i] != HTAB_EMPTY_ENTRY && entries[i] != HTAB_DELETED_ENTRY)
(*htab->del_f) (entries[i]);
memset (entries, 0, size * sizeof (PTR));
PTR *slot = htab->entries + index;
hashval_t hash2;
- if (*slot == EMPTY_ENTRY)
+ if (*slot == HTAB_EMPTY_ENTRY)
return slot;
- else if (*slot == DELETED_ENTRY)
+ else if (*slot == HTAB_DELETED_ENTRY)
abort ();
hash2 = htab_mod_m2 (hash, htab);
index -= size;
slot = htab->entries + index;
- if (*slot == EMPTY_ENTRY)
+ if (*slot == HTAB_EMPTY_ENTRY)
return slot;
- else if (*slot == DELETED_ENTRY)
+ else if (*slot == HTAB_DELETED_ENTRY)
abort ();
}
}
{
PTR x = *p;
- if (x != EMPTY_ENTRY && x != DELETED_ENTRY)
+ if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY)
{
PTR *q = find_empty_slot_for_expand (htab, (*htab->hash_f) (x));
index = htab_mod (hash, htab);
entry = htab->entries[index];
- if (entry == EMPTY_ENTRY
- || (entry != DELETED_ENTRY && (*htab->eq_f) (entry, element)))
+ if (entry == HTAB_EMPTY_ENTRY
+ || (entry != HTAB_DELETED_ENTRY && (*htab->eq_f) (entry, element)))
return entry;
hash2 = htab_mod_m2 (hash, htab);
index -= size;
entry = htab->entries[index];
- if (entry == EMPTY_ENTRY
- || (entry != DELETED_ENTRY && (*htab->eq_f) (entry, element)))
+ if (entry == HTAB_EMPTY_ENTRY
+ || (entry != HTAB_DELETED_ENTRY && (*htab->eq_f) (entry, element)))
return entry;
}
}
first_deleted_slot = NULL;
entry = htab->entries[index];
- if (entry == EMPTY_ENTRY)
+ if (entry == HTAB_EMPTY_ENTRY)
goto empty_entry;
- else if (entry == DELETED_ENTRY)
+ else if (entry == HTAB_DELETED_ENTRY)
first_deleted_slot = &htab->entries[index];
else if ((*htab->eq_f) (entry, element))
return &htab->entries[index];
index -= size;
entry = htab->entries[index];
- if (entry == EMPTY_ENTRY)
+ if (entry == HTAB_EMPTY_ENTRY)
goto empty_entry;
- else if (entry == DELETED_ENTRY)
+ else if (entry == HTAB_DELETED_ENTRY)
{
if (!first_deleted_slot)
first_deleted_slot = &htab->entries[index];
if (first_deleted_slot)
{
htab->n_deleted--;
- *first_deleted_slot = EMPTY_ENTRY;
+ *first_deleted_slot = HTAB_EMPTY_ENTRY;
return first_deleted_slot;
}
PTR *slot;
slot = htab_find_slot_with_hash (htab, element, hash, NO_INSERT);
- if (*slot == EMPTY_ENTRY)
+ if (*slot == HTAB_EMPTY_ENTRY)
return;
if (htab->del_f)
(*htab->del_f) (*slot);
- *slot = DELETED_ENTRY;
+ *slot = HTAB_DELETED_ENTRY;
htab->n_deleted++;
}
htab_clear_slot (htab_t htab, PTR *slot)
{
if (slot < htab->entries || slot >= htab->entries + htab_size (htab)
- || *slot == EMPTY_ENTRY || *slot == DELETED_ENTRY)
+ || *slot == HTAB_EMPTY_ENTRY || *slot == HTAB_DELETED_ENTRY)
abort ();
if (htab->del_f)
(*htab->del_f) (*slot);
- *slot = DELETED_ENTRY;
+ *slot = HTAB_DELETED_ENTRY;
htab->n_deleted++;
}
{
PTR *slot;
PTR *limit;
-
+
slot = htab->entries;
limit = slot + htab_size (htab);
{
PTR x = *slot;
- if (x != EMPTY_ENTRY && x != DELETED_ENTRY)
+ if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY)
if (!(*callback) (slot, info))
break;
}
projects / thirdparty / gcc.git / commitdiff
