{
{
GIMPLE_PASS,
- NULL, /* name */
+ "*referenced_vars", /* name */
NULL, /* gate */
find_referenced_vars, /* execute */
NULL, /* sub */
var_ann_t ann;
gcc_assert (t);
- gcc_assert (DECL_P (t));
- gcc_assert (!t->base.ann || t->base.ann->common.type == VAR_ANN);
+ gcc_assert (TREE_CODE (t) == VAR_DECL
+ || TREE_CODE (t) == PARM_DECL
+ || TREE_CODE (t) == RESULT_DECL);
ann = GGC_CNEW (struct var_ann_d);
- ann->common.type = VAR_ANN;
- t->base.ann = (tree_ann_t) ann;
+ *DECL_VAR_ANN_PTR (t) = ann;
return ann;
}
/* Renumber all of the gimple stmt uids. */
-void
+void
renumber_gimple_stmt_uids (void)
{
basic_block bb;
/* Like renumber_gimple_stmt_uids, but only do work on the basic blocks
in BLOCKS, of which there are N_BLOCKS. Also renumbers PHIs. */
-void
+void
renumber_gimple_stmt_uids_in_blocks (basic_block *blocks, int n_blocks)
{
int i;
}
}
-/* Create a new annotation for a tree T. */
-
-tree_ann_common_t
-create_tree_common_ann (tree t)
-{
- tree_ann_common_t ann;
-
- gcc_assert (t);
- gcc_assert (!t->base.ann || t->base.ann->common.type == TREE_ANN_COMMON);
-
- ann = GGC_CNEW (struct tree_ann_common_d);
-
- ann->type = TREE_ANN_COMMON;
- t->base.ann = (tree_ann_t) ann;
-
- return ann;
-}
-
/* Build a temporary. Make sure and register it to be renamed. */
tree
make_rename_temp (tree type, const char *prefix)
{
- tree t = create_tmp_var (type, prefix);
-
- if (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
- || TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
- DECL_GIMPLE_REG_P (t) = 1;
+ tree t = create_tmp_reg (type, prefix);
if (gimple_referenced_vars (cfun))
{
{
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_EACH_REFERENCED_VAR (var, rvi)
{
fprintf (file, "Variable: ");
ann = var_ann (var);
fprintf (file, ", UID D.%u", (unsigned) DECL_UID (var));
+ if (DECL_PT_UID (var) != DECL_UID (var))
+ fprintf (file, ", PT-UID D.%u", (unsigned) DECL_PT_UID (var));
fprintf (file, ", ");
print_generic_expr (file, TREE_TYPE (var), dump_flags);
if (TREE_ADDRESSABLE (var))
fprintf (file, ", is addressable");
-
+
if (is_global_var (var))
fprintf (file, ", is global");
if (TREE_THIS_VOLATILE (var))
fprintf (file, ", is volatile");
- if (is_call_clobbered (var))
- fprintf (file, ", call clobbered");
- else if (is_call_used (var))
- fprintf (file, ", call used");
-
if (ann && ann->noalias_state == NO_ALIAS)
fprintf (file, ", NO_ALIAS (does not alias other NO_ALIAS symbols)");
else if (ann && ann->noalias_state == NO_ALIAS_GLOBAL)
/* Lookup UID in the referenced_vars hashtable and return the associated
variable. */
-tree
+tree
referenced_var_lookup (unsigned int uid)
{
tree h;
return h;
}
-/* Check if TO is in the referenced_vars hash table and insert it if not.
+/* Check if TO is in the referenced_vars hash table and insert it if not.
Return true if it required insertion. */
bool
referenced_var_check_and_insert (tree to)
-{
+{
tree h, *loc;
struct tree_decl_minimal in;
unsigned int uid = DECL_UID (to);
/* Lookup VAR UID in the default_defs hashtable and return the associated
variable. */
-tree
+tree
gimple_default_def (struct function *fn, tree var)
{
struct tree_decl_minimal ind;
void
set_default_def (tree var, tree def)
-{
+{
struct tree_decl_minimal ind;
struct tree_ssa_name in;
void **loc;
bool
add_referenced_var (tree var)
{
- var_ann_t v_ann;
-
- v_ann = get_var_ann (var);
+ get_var_ann (var);
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))
{
&& (v_ann = var_ann (var)))
{
ggc_free (v_ann);
- var->base.ann = NULL;
+ *DECL_VAR_ANN_PTR (var) = NULL;
}
gcc_assert (DECL_P (var));
in.uid = uid;
{
HOST_WIDE_INT hthis_offset = TREE_INT_CST_LOW (this_offset);
hthis_offset *= BITS_PER_UNIT;
+ hthis_offset
+ += TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (field));
bit_offset += hthis_offset;
- bit_offset += TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (field));
+
+ /* If we had seen a variable array ref already and we just
+ referenced the last field of a struct or a union member
+ then we have to adjust maxsize by the padding at the end
+ of our field. */
+ if (seen_variable_array_ref
+ && maxsize != -1)
+ {
+ tree stype = TREE_TYPE (TREE_OPERAND (exp, 0));
+ tree next = TREE_CHAIN (field);
+ while (next && TREE_CODE (next) != FIELD_DECL)
+ next = TREE_CHAIN (next);
+ if (!next
+ || TREE_CODE (stype) != RECORD_TYPE)
+ {
+ tree fsize = DECL_SIZE_UNIT (field);
+ tree ssize = TYPE_SIZE_UNIT (stype);
+ if (host_integerp (fsize, 0)
+ && host_integerp (ssize, 0))
+ maxsize += ((TREE_INT_CST_LOW (ssize)
+ - TREE_INT_CST_LOW (fsize))
+ * BITS_PER_UNIT - hthis_offset);
+ else
+ maxsize = -1;
+ }
+ }
}
else
{
else
{
tree asize = TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp, 0)));
- /* Get at the array size but include trailing padding if
- the array is the last element of a struct or union. */
- if (maxsize != -1
- && TREE_CODE (TREE_OPERAND (exp, 0)) == COMPONENT_REF)
- {
- tree cref = TREE_OPERAND (exp, 0);
- tree field = TREE_OPERAND (cref, 1);
- tree stype = TREE_TYPE (TREE_OPERAND (cref, 0));
- tree next = TREE_CHAIN (field);
- while (next && TREE_CODE (next) != FIELD_DECL)
- next = TREE_CHAIN (next);
- if (!next
- || TREE_CODE (stype) != RECORD_TYPE)
- {
- /* The size including padding is the size of
- the whole structure minus the offset of the
- array in it. */
- tree field_offset = component_ref_field_offset (cref);
- if (field_offset
- && host_integerp (field_offset, 0)
- && host_integerp (TYPE_SIZE_UNIT (stype), 0))
- {
- unsigned HOST_WIDE_INT as;
- as = (((TREE_INT_CST_LOW (TYPE_SIZE_UNIT (stype))
- - TREE_INT_CST_LOW (field_offset))
- * BITS_PER_UNIT)
- - TREE_INT_CST_LOW
- (DECL_FIELD_BIT_OFFSET (field)));
- asize = build_int_cstu (sizetype, as);
- }
- else
- asize = NULL_TREE;
- }
- }
/* We need to adjust maxsize to the whole array bitsize.
But we can subtract any constant offset seen so far,
because that would get us outside of the array otherwise. */
break;
case VIEW_CONVERT_EXPR:
- /* ??? We probably should give up here and bail out. */
break;
default:
the array. The simplest way to conservatively deal with this
is to punt in the case that offset + maxsize reaches the
base type boundary. This needs to include possible trailing padding
- that is there for alignment purposes. */
+ that is there for alignment purposes.
- if (seen_variable_array_ref
- && (maxsize != -1
- && host_integerp (TYPE_SIZE (TREE_TYPE (exp)), 1)
- && bit_offset + maxsize
- == (signed) TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (exp)))))
+ That is of course only true if the base object is not a decl. */
+
+ if (DECL_P (exp))
+ {
+ /* If maxsize is unknown adjust it according to the size of the
+ base decl. */
+ if (maxsize == -1
+ && host_integerp (DECL_SIZE (exp), 1))
+ maxsize = TREE_INT_CST_LOW (DECL_SIZE (exp)) - bit_offset;
+ }
+ else if (seen_variable_array_ref
+ && maxsize != -1
+ && (!host_integerp (TYPE_SIZE (TREE_TYPE (exp)), 1)
+ || (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