long num_phis;
long num_phi_args;
int max_num_phi_args;
- long num_v_may_defs;
+ long num_vdefs;
long num_vuses;
- long num_v_must_defs;
-};
-
-
-/* State information for find_vars_r. */
-struct walk_state
-{
- /* Hash table used to avoid adding the same variable more than once. */
- htab_t vars_found;
};
static void collect_dfa_stats (struct dfa_stats_d *);
static tree collect_dfa_stats_r (tree *, int *, void *);
static tree find_vars_r (tree *, int *, void *);
-static void add_referenced_var (tree, struct walk_state *);
-
-
-/* Global declarations. */
-
-/* Array of all variables referenced in the function. */
-htab_t referenced_vars;
-
-/* Default definition for this symbols. If set for symbol, it
- means that the first reference to this variable in the function is a
- USE or a VUSE. In those cases, the SSA renamer creates an SSA name
- for this variable with an empty defining statement. */
-htab_t default_defs;
/*---------------------------------------------------------------------------
various attributes for each variable used by alias analysis and the
optimizer. */
-static void
+static unsigned int
find_referenced_vars (void)
{
- htab_t vars_found;
basic_block bb;
block_stmt_iterator si;
- struct walk_state walk_state;
-
- vars_found = htab_create (50, htab_hash_pointer, htab_eq_pointer, NULL);
- memset (&walk_state, 0, sizeof (walk_state));
- walk_state.vars_found = vars_found;
FOR_EACH_BB (bb)
for (si = bsi_start (bb); !bsi_end_p (si); bsi_next (&si))
{
tree *stmt_p = bsi_stmt_ptr (si);
- walk_tree (stmt_p, find_vars_r, &walk_state, NULL);
+ walk_tree (stmt_p, find_vars_r, NULL, NULL);
}
- htab_delete (vars_found);
+ return 0;
}
struct tree_opt_pass pass_referenced_vars =
create_var_ann (tree t)
{
var_ann_t ann;
+ struct static_var_ann_d *sann = NULL;
gcc_assert (t);
gcc_assert (DECL_P (t));
- gcc_assert (!t->common.ann || t->common.ann->common.type == VAR_ANN);
+ gcc_assert (!t->base.ann || t->base.ann->common.type == VAR_ANN);
- ann = GGC_NEW (struct var_ann_d);
- memset ((void *) ann, 0, sizeof (*ann));
+ if (!MTAG_P (t) && (TREE_STATIC (t) || DECL_EXTERNAL (t)))
+ {
+ sann = GGC_CNEW (struct static_var_ann_d);
+ ann = &sann->ann;
+ }
+ else
+ ann = GGC_CNEW (struct var_ann_d);
ann->common.type = VAR_ANN;
- t->common.ann = (tree_ann_t) ann;
+ if (!MTAG_P (t) && (TREE_STATIC (t) || DECL_EXTERNAL (t)))
+ {
+ void **slot;
+ sann->uid = DECL_UID (t);
+ slot = htab_find_slot_with_hash (gimple_var_anns (cfun),
+ t, DECL_UID (t), INSERT);
+ gcc_assert (!*slot);
+ *slot = sann;
+ }
+ else
+ t->base.ann = (tree_ann_t) ann;
return ann;
}
gcc_assert (t);
gcc_assert (TREE_CODE (t) == FUNCTION_DECL);
- gcc_assert (!t->common.ann || t->common.ann->common.type == FUNCTION_ANN);
+ gcc_assert (!t->base.ann || t->base.ann->common.type == FUNCTION_ANN);
ann = ggc_alloc (sizeof (*ann));
memset ((void *) ann, 0, sizeof (*ann));
ann->common.type = FUNCTION_ANN;
- t->common.ann = (tree_ann_t) ann;
+ t->base.ann = (tree_ann_t) ann;
return ann;
}
stmt_ann_t ann;
gcc_assert (is_gimple_stmt (t));
- gcc_assert (!t->common.ann || t->common.ann->common.type == STMT_ANN);
+ gcc_assert (!t->base.ann || t->base.ann->common.type == STMT_ANN);
- ann = GGC_NEW (struct stmt_ann_d);
- memset ((void *) ann, 0, sizeof (*ann));
+ ann = GGC_CNEW (struct stmt_ann_d);
ann->common.type = STMT_ANN;
/* Since we just created the annotation, mark the statement modified. */
ann->modified = true;
- t->common.ann = (tree_ann_t) ann;
+ t->base.ann = (tree_ann_t) ann;
return ann;
}
/* Create a new annotation for a tree T. */
-tree_ann_t
-create_tree_ann (tree t)
+tree_ann_common_t
+create_tree_common_ann (tree t)
{
- tree_ann_t ann;
+ tree_ann_common_t ann;
gcc_assert (t);
- gcc_assert (!t->common.ann || t->common.ann->common.type == TREE_ANN_COMMON);
+ gcc_assert (!t->base.ann || t->base.ann->common.type == TREE_ANN_COMMON);
- ann = GGC_NEW (union tree_ann_d);
- memset ((void *) ann, 0, sizeof (*ann));
+ ann = GGC_CNEW (struct tree_ann_common_d);
- ann->common.type = TREE_ANN_COMMON;
- t->common.ann = ann;
+ ann->type = TREE_ANN_COMMON;
+ t->base.ann = (tree_ann_t) ann;
return ann;
}
{
tree t = create_tmp_var (type, prefix);
- if (TREE_CODE (type) == COMPLEX_TYPE)
- DECL_COMPLEX_GIMPLE_REG_P (t) = 1;
+ if (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
+ || TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
+ DECL_GIMPLE_REG_P (t) = 1;
- if (referenced_vars)
+ if (gimple_referenced_vars (cfun))
{
- add_referenced_tmp_var (t);
+ add_referenced_var (t);
mark_sym_for_renaming (t);
}
fprintf (file, ", ");
print_generic_expr (file, TREE_TYPE (var), dump_flags);
- if (ann && ann->type_mem_tag)
+ if (ann && ann->symbol_mem_tag)
{
- fprintf (file, ", type memory tag: ");
- print_generic_expr (file, ann->type_mem_tag, dump_flags);
+ fprintf (file, ", symbol memory tag: ");
+ print_generic_expr (file, ann->symbol_mem_tag, dump_flags);
}
- if (ann && ann->is_aliased)
- fprintf (file, ", is aliased");
-
if (TREE_ADDRESSABLE (var))
fprintf (file, ", is addressable");
if (TREE_THIS_VOLATILE (var))
fprintf (file, ", is volatile");
+ if (mem_sym_stats (cfun, var))
+ {
+ mem_sym_stats_t stats = mem_sym_stats (cfun, var);
+ fprintf (file, ", direct reads: %ld", stats->num_direct_reads);
+ fprintf (file, ", direct writes: %ld", stats->num_direct_writes);
+ fprintf (file, ", indirect reads: %ld", stats->num_indirect_reads);
+ fprintf (file, ", indirect writes: %ld", stats->num_indirect_writes);
+ fprintf (file, ", read frequency: %ld", stats->frequency_reads);
+ fprintf (file, ", write frequency: %ld", stats->frequency_writes);
+ }
+
if (is_call_clobbered (var))
{
+ const char *s = "";
+ var_ann_t va = var_ann (var);
+ unsigned int escape_mask = va->escape_mask;
+
fprintf (file, ", call clobbered");
- if (dump_flags & TDF_DETAILS)
- {
- var_ann_t va = var_ann (var);
- unsigned int escape_mask = va->escape_mask;
-
- fprintf (file, " (");
- if (escape_mask & ESCAPE_STORED_IN_GLOBAL)
- fprintf (file, ", stored in global");
- if (escape_mask & ESCAPE_TO_ASM)
- fprintf (file, ", goes through ASM");
- if (escape_mask & ESCAPE_TO_CALL)
- fprintf (file, ", passed to call");
- if (escape_mask & ESCAPE_BAD_CAST)
- fprintf (file, ", bad cast");
- if (escape_mask & ESCAPE_TO_RETURN)
- fprintf (file, ", returned from func");
- if (escape_mask & ESCAPE_TO_PURE_CONST)
- fprintf (file, ", passed to pure/const");
- if (escape_mask & ESCAPE_IS_GLOBAL)
- fprintf (file, ", is global var");
- if (escape_mask & ESCAPE_IS_PARM)
- fprintf (file, ", is incoming pointer");
- if (escape_mask & ESCAPE_UNKNOWN)
- fprintf (file, ", unknown escape");
- fprintf (file, " )");
- }
+ fprintf (file, " (");
+ if (escape_mask & ESCAPE_STORED_IN_GLOBAL)
+ { fprintf (file, "%sstored in global", s); s = ", "; }
+ if (escape_mask & ESCAPE_TO_ASM)
+ { fprintf (file, "%sgoes through ASM", s); s = ", "; }
+ if (escape_mask & ESCAPE_TO_CALL)
+ { fprintf (file, "%spassed to call", s); s = ", "; }
+ if (escape_mask & ESCAPE_BAD_CAST)
+ { fprintf (file, "%sbad cast", s); s = ", "; }
+ if (escape_mask & ESCAPE_TO_RETURN)
+ { fprintf (file, "%sreturned from func", s); s = ", "; }
+ if (escape_mask & ESCAPE_TO_PURE_CONST)
+ { fprintf (file, "%spassed to pure/const", s); s = ", "; }
+ if (escape_mask & ESCAPE_IS_GLOBAL)
+ { fprintf (file, "%sis global var", s); s = ", "; }
+ if (escape_mask & ESCAPE_IS_PARM)
+ { fprintf (file, "%sis incoming pointer", s); s = ", "; }
+ if (escape_mask & ESCAPE_UNKNOWN)
+ { fprintf (file, "%sunknown escape", s); s = ", "; }
+ fprintf (file, ")");
}
- if (default_def (var))
+ if (ann->noalias_state == NO_ALIAS)
+ fprintf (file, ", NO_ALIAS (does not alias other NO_ALIAS symbols)");
+ else if (ann->noalias_state == NO_ALIAS_GLOBAL)
+ fprintf (file, ", NO_ALIAS_GLOBAL (does not alias other NO_ALIAS symbols"
+ " and global vars)");
+ else if (ann->noalias_state == NO_ALIAS_ANYTHING)
+ fprintf (file, ", NO_ALIAS_ANYTHING (does not alias any other symbols)");
+
+ if (gimple_default_def (cfun, var))
{
fprintf (file, ", default def: ");
- print_generic_expr (file, default_def (var), dump_flags);
+ print_generic_expr (file, gimple_default_def (cfun, var), dump_flags);
}
- if (may_aliases (var))
+ if (MTAG_P (var) && may_aliases (var))
{
fprintf (file, ", may aliases: ");
dump_may_aliases_for (file, var);
dump_subvars_for (file, var);
}
+ if (!is_gimple_reg (var))
+ {
+ if (memory_partition (var))
+ {
+ fprintf (file, ", belongs to partition: ");
+ print_generic_expr (file, memory_partition (var), dump_flags);
+ }
+
+ if (TREE_CODE (var) == MEMORY_PARTITION_TAG)
+ {
+ fprintf (file, ", partition symbols: ");
+ dump_decl_set (file, MPT_SYMBOLS (var));
+ }
+ }
+
fprintf (file, "\n");
}
fprintf (file, fmt_str_1, "VUSE operands", dfa_stats.num_vuses,
SCALE (size), LABEL (size));
- size = dfa_stats.num_v_may_defs * sizeof (tree *);
- total += size;
- fprintf (file, fmt_str_1, "V_MAY_DEF operands", dfa_stats.num_v_may_defs,
- SCALE (size), LABEL (size));
-
- size = dfa_stats.num_v_must_defs * sizeof (tree *);
+ size = dfa_stats.num_vdefs * sizeof (tree *);
total += size;
- fprintf (file, fmt_str_1, "V_MUST_DEF operands", dfa_stats.num_v_must_defs,
+ fprintf (file, fmt_str_1, "VDEF operands", dfa_stats.num_vdefs,
SCALE (size), LABEL (size));
size = dfa_stats.num_phis * sizeof (struct tree_phi_node);
tree t = *tp;
struct dfa_stats_d *dfa_stats_p = (struct dfa_stats_d *)data;
- if (t->common.ann)
+ if (t->base.ann)
{
- switch (ann_type (t->common.ann))
+ switch (ann_type (t->base.ann))
{
case STMT_ANN:
{
dfa_stats_p->num_stmt_anns++;
dfa_stats_p->num_defs += NUM_SSA_OPERANDS (t, SSA_OP_DEF);
dfa_stats_p->num_uses += NUM_SSA_OPERANDS (t, SSA_OP_USE);
- dfa_stats_p->num_v_may_defs += NUM_SSA_OPERANDS (t, SSA_OP_VMAYDEF);
+ dfa_stats_p->num_vdefs += NUM_SSA_OPERANDS (t, SSA_OP_VDEF);
dfa_stats_p->num_vuses += NUM_SSA_OPERANDS (t, SSA_OP_VUSE);
- dfa_stats_p->num_v_must_defs +=
- NUM_SSA_OPERANDS (t, SSA_OP_VMUSTDEF);
break;
}
the function. */
static tree
-find_vars_r (tree *tp, int *walk_subtrees, void *data)
+find_vars_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
{
- struct walk_state *walk_state = (struct walk_state *) data;
-
/* If T is a regular variable that the optimizers are interested
in, add it to the list of variables. */
if (SSA_VAR_P (*tp))
- add_referenced_var (*tp, walk_state);
+ add_referenced_var (*tp);
/* Type, _DECL and constant nodes have no interesting children.
Ignore them. */
return NULL_TREE;
}
-
-/* Lookup UID in the referenced_vars hashtable and return the associated
- variable or NULL if it is not there. */
-
-tree
-referenced_var_lookup_if_exists (unsigned int uid)
-{
- struct int_tree_map *h, in;
- in.uid = uid;
- h = (struct int_tree_map *) htab_find_with_hash (referenced_vars, &in, uid);
- if (h)
- return h->to;
- return NULL_TREE;
-}
-
/* Lookup UID in the referenced_vars hashtable and return the associated
variable. */
{
struct int_tree_map *h, in;
in.uid = uid;
- h = (struct int_tree_map *) htab_find_with_hash (referenced_vars, &in, uid);
+ h = (struct int_tree_map *)
+ htab_find_with_hash (gimple_referenced_vars (cfun), &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. */
+/* Check if TO is in the referenced_vars hash table and insert it if not.
+ Return true if it required insertion. */
-static void
-referenced_var_insert (unsigned int uid, tree to)
+bool
+referenced_var_check_and_insert (tree to)
{
- struct int_tree_map *h;
+ struct int_tree_map *h, in;
void **loc;
+ unsigned int uid = DECL_UID (to);
+
+ in.uid = uid;
+ in.to = to;
+ h = (struct int_tree_map *) htab_find_with_hash (gimple_referenced_vars (cfun),
+ &in, uid);
+
+ if (h)
+ {
+ /* DECL_UID has already been entered in the table. Verify that it is
+ the same entry as TO. See PR 27793. */
+ gcc_assert (h->to == to);
+ return false;
+ }
h = GGC_NEW (struct int_tree_map);
h->uid = uid;
h->to = to;
- loc = htab_find_slot_with_hash (referenced_vars, h, uid, INSERT);
+ loc = htab_find_slot_with_hash (gimple_referenced_vars (cfun),
+ h, uid, INSERT);
*(struct int_tree_map **) loc = h;
+ return true;
}
/* Lookup VAR UID in the default_defs hashtable and return the associated
variable. */
tree
-default_def (tree var)
+gimple_default_def (struct function *fn, tree var)
{
struct int_tree_map *h, in;
gcc_assert (SSA_VAR_P (var));
in.uid = DECL_UID (var);
- h = (struct int_tree_map *) htab_find_with_hash (default_defs, &in,
+ h = (struct int_tree_map *) htab_find_with_hash (DEFAULT_DEFS (fn),
+ &in,
DECL_UID (var));
if (h)
return h->to;
gcc_assert (SSA_VAR_P (var));
in.uid = DECL_UID (var);
- if (!def && default_def (var))
+ if (!def && gimple_default_def (cfun, var))
{
- loc = htab_find_slot_with_hash (default_defs, &in, DECL_UID (var), INSERT);
- htab_remove_elt (default_defs, *loc);
+ loc = htab_find_slot_with_hash (DEFAULT_DEFS (cfun), &in,
+ DECL_UID (var), INSERT);
+ htab_remove_elt (DEFAULT_DEFS (cfun), *loc);
return;
}
- gcc_assert (TREE_CODE (def) == SSA_NAME);
- loc = htab_find_slot_with_hash (default_defs, &in, DECL_UID (var), INSERT);
+ gcc_assert (!def || TREE_CODE (def) == SSA_NAME);
+ loc = htab_find_slot_with_hash (DEFAULT_DEFS (cfun), &in,
+ DECL_UID (var), INSERT);
+
/* Default definition might be changed by tail call optimization. */
if (!*loc)
{
else
{
h = (struct int_tree_map *) *loc;
+ SSA_NAME_IS_DEFAULT_DEF (h->to) = false;
h->to = def;
}
-}
-/* Add VAR to the list of dereferenced variables.
+ /* Mark DEF as the default definition for VAR. */
+ SSA_NAME_IS_DEFAULT_DEF (def) = true;
+}
- WALK_STATE contains a hash table used to avoid adding the same
- variable more than once. Note that this function assumes that
- VAR is a valid SSA variable. If WALK_STATE is NULL, no
- duplicate checking is done. */
+/* Add VAR to the list of referenced variables if it isn't already there. */
-static void
-add_referenced_var (tree var, struct walk_state *walk_state)
+void
+add_referenced_var (tree var)
{
- void **slot;
var_ann_t v_ann;
v_ann = get_var_ann (var);
-
- if (walk_state)
- slot = htab_find_slot (walk_state->vars_found, (void *) var, INSERT);
- else
- slot = NULL;
-
- if (slot == NULL || *slot == NULL)
+ gcc_assert (DECL_P (var));
+
+ /* Insert VAR into the referenced_vars has table if it isn't present. */
+ if (referenced_var_check_and_insert (var))
{
- /* This is the first time we find this variable, add it to the
- REFERENCED_VARS array and annotate it with attributes that are
- intrinsic to the variable. */
- if (slot)
- *slot = (void *) var;
-
- referenced_var_insert (DECL_UID (var), var);
+ /* This is the first time we found this variable, annotate it with
+ attributes that are intrinsic to the variable. */
/* Tag's don't have DECL_INITIAL. */
if (MTAG_P (var))
/* Scan DECL_INITIAL for pointer variables as they may contain
address arithmetic referencing the address of other
- variables. */
+ variables.
+ Even non-constant intializers need to be walked, because
+ IPA passes might prove that their are invariant later on. */
if (DECL_INITIAL (var)
/* Initializers of external variables are not useful to the
optimizers. */
- && !DECL_EXTERNAL (var)
- /* It's not necessary to walk the initial value of non-constant
- variables because it cannot be propagated by the
- optimizers. */
- && (TREE_CONSTANT (var) || TREE_READONLY (var)))
- walk_tree (&DECL_INITIAL (var), find_vars_r, walk_state, 0);
+ && !DECL_EXTERNAL (var))
+ walk_tree (&DECL_INITIAL (var), find_vars_r, NULL, 0);
}
}
+/* Remove VAR from the list. */
+
+void
+remove_referenced_var (tree var)
+{
+ var_ann_t v_ann;
+ struct int_tree_map in;
+ void **loc;
+ unsigned int uid = DECL_UID (var);
+
+ clear_call_clobbered (var);
+ v_ann = get_var_ann (var);
+ ggc_free (v_ann);
+ var->base.ann = NULL;
+ gcc_assert (DECL_P (var));
+ in.uid = uid;
+ in.to = var;
+ loc = htab_find_slot_with_hash (gimple_referenced_vars (cfun), &in, uid,
+ NO_INSERT);
+ ggc_free (*loc);
+ htab_clear_slot (gimple_referenced_vars (cfun), loc);
+}
+
/* Return the virtual variable associated to the non-scalar variable VAR. */
return var;
}
-/* Add a temporary variable to REFERENCED_VARS. This is similar to
- add_referenced_var, but is used by passes that need to add new temps to
- the REFERENCED_VARS array after the program has been scanned for
- variables. The variable will just receive a new UID and be added
- to the REFERENCED_VARS array without checking for duplicates. */
-
-void
-add_referenced_tmp_var (tree var)
-{
- add_referenced_var (var, NULL);
-}
-
-
-/* Mark all the non-SSA variables found in STMT's operands to be
- processed by update_ssa. */
+/* Mark all the naked symbols in STMT for SSA renaming.
+
+ NOTE: This function should only be used for brand new statements.
+ If the caller is modifying an existing statement, it should use the
+ combination push_stmt_changes/pop_stmt_changes. */
void
-mark_new_vars_to_rename (tree stmt)
+mark_symbols_for_renaming (tree stmt)
{
+ tree op;
ssa_op_iter iter;
- tree val;
- bitmap vars_in_vops_to_rename;
- bool found_exposed_symbol = false;
- int v_may_defs_before, v_may_defs_after;
- int v_must_defs_before, v_must_defs_after;
-
- if (TREE_CODE (stmt) == PHI_NODE)
- return;
-
- get_stmt_ann (stmt);
- vars_in_vops_to_rename = BITMAP_ALLOC (NULL);
- /* Before re-scanning the statement for operands, mark the existing
- virtual operands to be renamed again. We do this because when new
- symbols are exposed, the virtual operands that were here before due to
- aliasing will probably be removed by the call to get_stmt_operand.
- Therefore, we need to flag them to be renamed beforehand.
-
- We flag them in a separate bitmap because we don't really want to
- rename them if there are not any newly exposed symbols in the
- statement operands. */
- v_may_defs_before = NUM_SSA_OPERANDS (stmt, SSA_OP_VMAYDEF);
- v_must_defs_before = NUM_SSA_OPERANDS (stmt, SSA_OP_VMUSTDEF);
-
- FOR_EACH_SSA_TREE_OPERAND (val, stmt, iter,
- SSA_OP_VMAYDEF | SSA_OP_VUSE | SSA_OP_VMUSTDEF)
- {
- if (!DECL_P (val))
- val = SSA_NAME_VAR (val);
- bitmap_set_bit (vars_in_vops_to_rename, DECL_UID (val));
- }
-
- /* Now force an operand re-scan on the statement and mark any newly
- exposed variables. */
update_stmt (stmt);
- v_may_defs_after = NUM_SSA_OPERANDS (stmt, SSA_OP_VMAYDEF);
- v_must_defs_after = NUM_SSA_OPERANDS (stmt, SSA_OP_VMUSTDEF);
-
- FOR_EACH_SSA_TREE_OPERAND (val, stmt, iter, SSA_OP_ALL_OPERANDS)
- if (DECL_P (val))
- {
- found_exposed_symbol = true;
- mark_sym_for_renaming (val);
- }
-
- /* If we found any newly exposed symbols, or if there are fewer VDEF
- operands in the statement, add the variables we had set in
- VARS_IN_VOPS_TO_RENAME to VARS_TO_RENAME. We need to check for
- vanishing VDEFs because in those cases, the names that were formerly
- generated by this statement are not going to be available anymore. */
- if (found_exposed_symbol
- || v_may_defs_before > v_may_defs_after
- || v_must_defs_before > v_must_defs_after)
- mark_set_for_renaming (vars_in_vops_to_rename);
-
- BITMAP_FREE (vars_in_vops_to_rename);
+ /* Mark all the operands for renaming. */
+ FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_ALL_OPERANDS)
+ if (DECL_P (op))
+ mark_sym_for_renaming (op);
}
+
/* Find all variables within the gimplified statement that were not previously
visible to the function and add them to the referenced variables list. */
if (TREE_CODE (t) == VAR_DECL && !var_ann (t))
{
- add_referenced_tmp_var (t);
+ add_referenced_var (t);
mark_sym_for_renaming (t);
}
}
-/* If REF is a handled component reference for a structure, return the
+/* If EXP is a handled component reference for a structure, return the
base variable. The access range is delimited by bit positions *POFFSET and
*POFFSET + *PMAX_SIZE. The access size is *PSIZE bits. If either
*PSIZE or *PMAX_SIZE is -1, they could not be determined. If *PSIZE
HOST_WIDE_INT bitsize = -1;
HOST_WIDE_INT maxsize = -1;
tree size_tree = NULL_TREE;
- tree bit_offset = bitsize_zero_node;
+ HOST_WIDE_INT bit_offset = 0;
bool seen_variable_array_ref = false;
gcc_assert (!SSA_VAR_P (exp));
switch (TREE_CODE (exp))
{
case BIT_FIELD_REF:
- bit_offset = size_binop (PLUS_EXPR, bit_offset,
- TREE_OPERAND (exp, 2));
+ bit_offset += tree_low_cst (TREE_OPERAND (exp, 2), 0);
break;
case COMPONENT_REF:
if (this_offset && TREE_CODE (this_offset) == INTEGER_CST)
{
- this_offset = size_binop (MULT_EXPR,
- fold_convert (bitsizetype,
- this_offset),
- bitsize_unit_node);
- bit_offset = size_binop (PLUS_EXPR,
- bit_offset, this_offset);
- bit_offset = size_binop (PLUS_EXPR, bit_offset,
- DECL_FIELD_BIT_OFFSET (field));
+ HOST_WIDE_INT hthis_offset = tree_low_cst (this_offset, 0);
+
+ hthis_offset *= BITS_PER_UNIT;
+ bit_offset += hthis_offset;
+ bit_offset += tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 0);
}
else
{
/* We need to adjust maxsize to the whole structure bitsize.
But we can subtract any constant offset seen sofar,
because that would get us out of the structure otherwise. */
- if (maxsize != -1
- && csize && host_integerp (csize, 1))
- {
- maxsize = (TREE_INT_CST_LOW (csize)
- - TREE_INT_CST_LOW (bit_offset));
- }
+ if (maxsize != -1 && csize && host_integerp (csize, 1))
+ maxsize = TREE_INT_CST_LOW (csize) - bit_offset;
else
maxsize = -1;
}
tree low_bound = array_ref_low_bound (exp);
tree unit_size = array_ref_element_size (exp);
- if (! integer_zerop (low_bound))
- index = fold_build2 (MINUS_EXPR, TREE_TYPE (index),
- index, low_bound);
- index = size_binop (MULT_EXPR,
- fold_convert (sizetype, index), unit_size);
- if (TREE_CODE (index) == INTEGER_CST)
+ /* If the resulting bit-offset is constant, track it. */
+ if (host_integerp (index, 0)
+ && host_integerp (low_bound, 0)
+ && host_integerp (unit_size, 1))
{
- index = size_binop (MULT_EXPR,
- fold_convert (bitsizetype, index),
- bitsize_unit_node);
- bit_offset = size_binop (PLUS_EXPR, bit_offset, index);
+ HOST_WIDE_INT hindex = tree_low_cst (index, 0);
+
+ hindex -= tree_low_cst (low_bound, 0);
+ hindex *= tree_low_cst (unit_size, 1);
+ hindex *= BITS_PER_UNIT;
+ bit_offset += hindex;
/* An array ref with a constant index up in the structure
hierarchy will constrain the size of any variable array ref
/* We need to adjust maxsize to the whole array bitsize.
But we can subtract any constant offset seen sofar,
because that would get us outside of the array otherwise. */
- if (maxsize != -1
- && asize && host_integerp (asize, 1))
- {
- maxsize = (TREE_INT_CST_LOW (asize)
- - TREE_INT_CST_LOW (bit_offset));
- }
+ if (maxsize != -1 && asize && host_integerp (asize, 1))
+ maxsize = TREE_INT_CST_LOW (asize) - bit_offset;
else
maxsize = -1;
break;
case IMAGPART_EXPR:
- bit_offset = size_binop (PLUS_EXPR, bit_offset,
- bitsize_int (bitsize));
+ bit_offset += bitsize;
break;
case VIEW_CONVERT_EXPR:
if (seen_variable_array_ref
&& maxsize != -1
&& host_integerp (TYPE_SIZE (TREE_TYPE (exp)), 1)
- && TREE_INT_CST_LOW (bit_offset) + maxsize
- == TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (exp))))
+ && bit_offset + maxsize
+ == (signed)TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (exp))))
maxsize = -1;
/* ??? Due to negative offsets in ARRAY_REF we can end up with
negative bit_offset here. We might want to store a zero offset
in this case. */
- *poffset = TREE_INT_CST_LOW (bit_offset);
+ *poffset = bit_offset;
*psize = bitsize;
*pmax_size = maxsize;
return exp;
}
+
+
+/* Return memory reference statistics for variable VAR in function FN.
+ This is computed by alias analysis, but it is not kept
+ incrementally up-to-date. So, these stats are only accurate if
+ pass_may_alias has been run recently. If no alias information
+ exists, this function returns NULL. */
+
+mem_sym_stats_t
+mem_sym_stats (struct function *fn, tree var)
+{
+ void **slot;
+ struct pointer_map_t *stats_map = gimple_mem_ref_stats (fn)->mem_sym_stats;
+
+ if (stats_map == NULL)
+ return NULL;
+
+ slot = pointer_map_contains (stats_map, var);
+ if (slot == NULL)
+ return NULL;
+
+ return (mem_sym_stats_t) *slot;
+}