/* Data flow functions for trees.
- Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
+ Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
+ Free Software Foundation, Inc.
Contributed by Diego Novillo <dnovillo@redhat.com>
This file is part of GCC.
#include "hashtab.h"
#include "pointer-set.h"
#include "tree.h"
-#include "rtl.h"
#include "tm_p.h"
-#include "hard-reg-set.h"
#include "basic-block.h"
-#include "output.h"
-#include "timevar.h"
-#include "expr.h"
#include "ggc.h"
#include "langhooks.h"
#include "flags.h"
#include "function.h"
-#include "diagnostic.h"
-#include "tree-dump.h"
-#include "tree-gimple.h"
+#include "tree-pretty-print.h"
+#include "gimple.h"
#include "tree-flow.h"
#include "tree-inline.h"
#include "tree-pass.h"
/* Counters used to display DFA and SSA statistics. */
struct dfa_stats_d
{
- long num_stmt_anns;
long num_var_anns;
long num_defs;
long num_uses;
long num_phis;
long num_phi_args;
- int max_num_phi_args;
+ size_t max_num_phi_args;
long num_vdefs;
long num_vuses;
};
/* Local functions. */
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 *);
/*---------------------------------------------------------------------------
find_referenced_vars (void)
{
basic_block bb;
- block_stmt_iterator si;
- tree phi;
+ gimple_stmt_iterator si;
FOR_EACH_BB (bb)
{
- for (si = bsi_start (bb); !bsi_end_p (si); bsi_next (&si))
+ for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
{
- tree *stmt_p = bsi_stmt_ptr (si);
- walk_tree (stmt_p, find_vars_r, NULL, NULL);
+ gimple stmt = gsi_stmt (si);
+ if (is_gimple_debug (stmt))
+ continue;
+ find_referenced_vars_in (gsi_stmt (si));
}
- for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
- {
- int len = PHI_NUM_ARGS (phi);
- int i;
-
- walk_tree (&phi, find_vars_r, NULL, NULL);
-
- for (i = 0; i < len; i++)
- {
- tree arg = PHI_ARG_DEF (phi, i);
- walk_tree (&arg, find_vars_r, NULL, NULL);
- }
- }
+ for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
+ find_referenced_vars_in (gsi_stmt (si));
}
return 0;
{
{
GIMPLE_PASS,
- NULL, /* name */
+ "*referenced_vars", /* name */
NULL, /* gate */
find_referenced_vars, /* execute */
NULL, /* sub */
PROP_gimple_leh | PROP_cfg, /* properties_required */
PROP_referenced_vars, /* properties_provided */
0, /* properties_destroyed */
- TODO_dump_func, /* todo_flags_start */
- TODO_dump_func /* todo_flags_finish */
+ 0, /* todo_flags_start */
+ 0 /* todo_flags_finish */
}
};
-/*---------------------------------------------------------------------------
- Manage annotations
----------------------------------------------------------------------------*/
-/* Create a new annotation for a _DECL node T. */
-
-var_ann_t
-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->base.ann || t->base.ann->common.type == VAR_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;
-
- 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;
-}
-
-/* Create a new annotation for a FUNCTION_DECL node T. */
-
-function_ann_t
-create_function_ann (tree t)
-{
- function_ann_t ann;
-
- gcc_assert (t);
- gcc_assert (TREE_CODE (t) == FUNCTION_DECL);
- 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->base.ann = (tree_ann_t) ann;
-
- return ann;
-}
-
-/* Create a new annotation for a statement node T. */
-
-stmt_ann_t
-create_stmt_ann (tree t)
-{
- stmt_ann_t ann;
-
- gcc_assert (is_gimple_stmt (t));
- gcc_assert (!t->base.ann || t->base.ann->common.type == STMT_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;
-
- ann->uid = inc_gimple_stmt_max_uid (cfun);
- t->base.ann = (tree_ann_t) ann;
-
- return ann;
-}
-
/* Renumber all of the gimple stmt uids. */
-void
+void
renumber_gimple_stmt_uids (void)
{
basic_block bb;
set_gimple_stmt_max_uid (cfun, 0);
FOR_ALL_BB (bb)
{
- block_stmt_iterator bsi;
- for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
+ gimple_stmt_iterator bsi;
+ for (bsi = gsi_start_phis (bb); !gsi_end_p (bsi); gsi_next (&bsi))
{
- tree stmt = bsi_stmt (bsi);
- /* If the stmt has an annotation, then overwrite it, if not,
- the process of getting it will set the number
- properly. */
- if (has_stmt_ann (stmt))
- set_gimple_stmt_uid (stmt, inc_gimple_stmt_max_uid (cfun));
- else
- get_stmt_ann (stmt);
+ gimple stmt = gsi_stmt (bsi);
+ gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
+ }
+ for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
+ {
+ gimple stmt = gsi_stmt (bsi);
+ gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
}
}
}
-/* Create a new annotation for a tree T. */
+/* Like renumber_gimple_stmt_uids, but only do work on the basic blocks
+ in BLOCKS, of which there are N_BLOCKS. Also renumbers PHIs. */
-tree_ann_common_t
-create_tree_common_ann (tree t)
+void
+renumber_gimple_stmt_uids_in_blocks (basic_block *blocks, int n_blocks)
{
- 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;
+ int i;
- return ann;
+ set_gimple_stmt_max_uid (cfun, 0);
+ for (i = 0; i < n_blocks; i++)
+ {
+ basic_block bb = blocks[i];
+ gimple_stmt_iterator bsi;
+ for (bsi = gsi_start_phis (bb); !gsi_end_p (bsi); gsi_next (&bsi))
+ {
+ gimple stmt = gsi_stmt (bsi);
+ gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
+ }
+ for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
+ {
+ gimple stmt = gsi_stmt (bsi);
+ gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
+ }
+ }
}
/* 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))
- {
- add_referenced_var (t);
- mark_sym_for_renaming (t);
- }
+ add_referenced_var (t);
+ if (gimple_in_ssa_p (cfun))
+ mark_sym_for_renaming (t);
return t;
}
{
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)
+
+ FOR_EACH_REFERENCED_VAR (cfun, var, rvi)
{
fprintf (file, "Variable: ");
dump_variable (file, var);
- fprintf (file, "\n");
}
+
+ fprintf (file, "\n");
}
/* Dump the list of all the referenced variables to stderr. */
-void
+DEBUG_FUNCTION void
debug_referenced_vars (void)
{
dump_referenced_vars (stderr);
void
dump_variable (FILE *file, tree var)
{
- var_ann_t ann;
-
if (TREE_CODE (var) == SSA_NAME)
{
if (POINTER_TYPE_P (TREE_TYPE (var)))
print_generic_expr (file, var, dump_flags);
- 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 (ann && ann->symbol_mem_tag)
- {
- fprintf (file, ", symbol memory tag: ");
- print_generic_expr (file, ann->symbol_mem_tag, 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");
- dump_mem_sym_stats_for_var (file, var);
-
- 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");
- 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 (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))
+ if (cfun && gimple_default_def (cfun, var))
{
fprintf (file, ", default def: ");
print_generic_expr (file, gimple_default_def (cfun, var), dump_flags);
}
- if (MTAG_P (var) && may_aliases (var))
+ if (DECL_INITIAL (var))
{
- fprintf (file, ", may aliases: ");
- dump_may_aliases_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, ", initial: ");
+ print_generic_expr (file, DECL_INITIAL (var), dump_flags);
}
fprintf (file, "\n");
/* Dump variable VAR and its may-aliases to stderr. */
-void
+DEBUG_FUNCTION void
debug_variable (tree var)
{
dump_variable (stderr, var);
fprintf (file, fmt_str_1, "Referenced variables", (unsigned long)num_referenced_vars,
SCALE (size), LABEL (size));
- size = dfa_stats.num_stmt_anns * sizeof (struct stmt_ann_d);
- total += size;
- fprintf (file, fmt_str_1, "Statements annotated", dfa_stats.num_stmt_anns,
- SCALE (size), LABEL (size));
-
size = dfa_stats.num_var_anns * sizeof (struct var_ann_d);
total += size;
fprintf (file, fmt_str_1, "Variables annotated", dfa_stats.num_var_anns,
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);
+ size = dfa_stats.num_phis * sizeof (struct gimple_statement_phi);
total += size;
fprintf (file, fmt_str_1, "PHI nodes", dfa_stats.num_phis,
SCALE (size), LABEL (size));
fprintf (file, "\n");
if (dfa_stats.num_phis)
- fprintf (file, "Average number of arguments per PHI node: %.1f (max: %d)\n",
+ fprintf (file, "Average number of arguments per PHI node: %.1f (max: %ld)\n",
(float) dfa_stats.num_phi_args / (float) dfa_stats.num_phis,
- dfa_stats.max_num_phi_args);
+ (long) dfa_stats.max_num_phi_args);
fprintf (file, "\n");
}
/* Dump DFA statistics on stderr. */
-void
+DEBUG_FUNCTION void
debug_dfa_stats (void)
{
dump_dfa_stats (stderr);
DFA_STATS_P. */
static void
-collect_dfa_stats (struct dfa_stats_d *dfa_stats_p)
+collect_dfa_stats (struct dfa_stats_d *dfa_stats_p ATTRIBUTE_UNUSED)
{
- struct pointer_set_t *pset;
basic_block bb;
- block_stmt_iterator i;
gcc_assert (dfa_stats_p);
memset ((void *)dfa_stats_p, 0, sizeof (struct dfa_stats_d));
- /* Walk all the trees in the function counting references. Start at
- basic block NUM_FIXED_BLOCKS, but don't stop at block boundaries. */
- pset = pointer_set_create ();
-
- for (i = bsi_start (BASIC_BLOCK (NUM_FIXED_BLOCKS));
- !bsi_end_p (i); bsi_next (&i))
- walk_tree (bsi_stmt_ptr (i), collect_dfa_stats_r, (void *) dfa_stats_p,
- pset);
-
- pointer_set_destroy (pset);
+ /* Count all the variable annotations. */
+ dfa_stats_p->num_var_anns = htab_elements (gimple_referenced_vars (cfun));
+ /* Walk all the statements in the function counting references. */
FOR_EACH_BB (bb)
{
- tree phi;
- for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
+ gimple_stmt_iterator si;
+
+ for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
{
+ gimple phi = gsi_stmt (si);
dfa_stats_p->num_phis++;
- dfa_stats_p->num_phi_args += PHI_NUM_ARGS (phi);
- if (PHI_NUM_ARGS (phi) > dfa_stats_p->max_num_phi_args)
- dfa_stats_p->max_num_phi_args = PHI_NUM_ARGS (phi);
+ dfa_stats_p->num_phi_args += gimple_phi_num_args (phi);
+ if (gimple_phi_num_args (phi) > dfa_stats_p->max_num_phi_args)
+ dfa_stats_p->max_num_phi_args = gimple_phi_num_args (phi);
}
- }
-}
-
-
-/* Callback for walk_tree to collect DFA statistics for a tree and its
- children. */
-
-static tree
-collect_dfa_stats_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
- void *data)
-{
- tree t = *tp;
- struct dfa_stats_d *dfa_stats_p = (struct dfa_stats_d *)data;
- if (t->base.ann)
- {
- switch (ann_type (t->base.ann))
+ for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
{
- 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_vdefs += NUM_SSA_OPERANDS (t, SSA_OP_VDEF);
- dfa_stats_p->num_vuses += NUM_SSA_OPERANDS (t, SSA_OP_VUSE);
- break;
- }
-
- case VAR_ANN:
- dfa_stats_p->num_var_anns++;
- break;
-
- default:
- break;
+ gimple stmt = gsi_stmt (si);
+ dfa_stats_p->num_defs += NUM_SSA_OPERANDS (stmt, SSA_OP_DEF);
+ dfa_stats_p->num_uses += NUM_SSA_OPERANDS (stmt, SSA_OP_USE);
+ dfa_stats_p->num_vdefs += gimple_vdef (stmt) ? 1 : 0;
+ dfa_stats_p->num_vuses += gimple_vuse (stmt) ? 1 : 0;
}
}
-
- return NULL;
}
the function. */
static tree
-find_vars_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
+find_vars_r (tree *tp, int *walk_subtrees, void *data)
{
+ struct function *fn = (struct function *) data;
+
/* If we are reading the lto info back in, we need to rescan the
referenced vars. */
if (TREE_CODE (*tp) == SSA_NAME)
- add_referenced_var (SSA_NAME_VAR (*tp));
+ add_referenced_var_1 (SSA_NAME_VAR (*tp), fn);
/* If T is a regular variable that the optimizers are interested
in, add it to the list of variables. */
- else if (SSA_VAR_P (*tp))
- add_referenced_var (*tp);
+ else if ((TREE_CODE (*tp) == VAR_DECL
+ && !is_global_var (*tp))
+ || TREE_CODE (*tp) == PARM_DECL
+ || TREE_CODE (*tp) == RESULT_DECL)
+ add_referenced_var_1 (*tp, fn);
/* Type, _DECL and constant nodes have no interesting children.
Ignore them. */
return NULL_TREE;
}
+/* Find referenced variables in STMT. */
+
+void
+find_referenced_vars_in (gimple stmt)
+{
+ size_t i;
+
+ if (gimple_code (stmt) != GIMPLE_PHI)
+ {
+ for (i = 0; i < gimple_num_ops (stmt); i++)
+ walk_tree (gimple_op_ptr (stmt, i), find_vars_r, cfun, NULL);
+ }
+ else
+ {
+ walk_tree (gimple_phi_result_ptr (stmt), find_vars_r, cfun, NULL);
+
+ for (i = 0; i < gimple_phi_num_args (stmt); i++)
+ {
+ tree arg = gimple_phi_arg_def (stmt, i);
+ walk_tree (&arg, find_vars_r, cfun, NULL);
+ }
+ }
+}
+
+
/* Lookup UID in the referenced_vars hashtable and return the associated
variable. */
-tree
-referenced_var_lookup (unsigned int uid)
+tree
+referenced_var_lookup (struct function *fn, unsigned int uid)
{
tree h;
struct tree_decl_minimal in;
in.uid = uid;
- h = (tree) htab_find_with_hash (gimple_referenced_vars (cfun), &in, uid);
- gcc_assert (h || uid == 0);
+ h = (tree) htab_find_with_hash (gimple_referenced_vars (fn), &in, uid);
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;
+static bool
+referenced_var_check_and_insert (tree to, struct function *fn)
+{
+ tree *loc;
struct tree_decl_minimal in;
unsigned int uid = DECL_UID (to);
in.uid = uid;
- h = (tree) htab_find_with_hash (gimple_referenced_vars (cfun), &in, uid);
- if (h)
+ loc = (tree *) htab_find_slot_with_hash (gimple_referenced_vars (fn),
+ &in, uid, INSERT);
+ if (*loc)
{
/* 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);
+ gcc_assert (*loc == to);
return false;
}
- loc = (tree *) htab_find_slot_with_hash (gimple_referenced_vars (cfun),
- &in, uid, INSERT);
*loc = to;
return true;
}
/* 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;
/* Add VAR to the list of referenced variables if it isn't already there. */
-void
-add_referenced_var (tree var)
+bool
+add_referenced_var_1 (tree var, struct function *fn)
{
- var_ann_t v_ann;
+ gcc_checking_assert (TREE_CODE (var) == VAR_DECL
+ || TREE_CODE (var) == PARM_DECL
+ || TREE_CODE (var) == RESULT_DECL);
- v_ann = 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))
+ gcc_checking_assert ((TREE_CODE (var) == VAR_DECL
+ && VAR_DECL_IS_VIRTUAL_OPERAND (var))
+ || !is_global_var (var));
+
+ /* Insert VAR into the referenced_vars hash table if it isn't present
+ and allocate its var-annotation. */
+ if (referenced_var_check_and_insert (var, fn))
{
- /* 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))
- return;
-
- /* Scan DECL_INITIAL for pointer variables as they may contain
- address arithmetic referencing the address of other
- 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))
- walk_tree (&DECL_INITIAL (var), find_vars_r, NULL, 0);
+ gcc_checking_assert (!*DECL_VAR_ANN_PTR (var));
+ *DECL_VAR_ANN_PTR (var) = ggc_alloc_cleared_var_ann_d ();
+ return true;
}
+
+ return false;
}
-/* Remove VAR from the list. */
+/* Remove VAR from the list of referenced variables and clear its
+ var-annotation. */
void
remove_referenced_var (tree var)
void **loc;
unsigned int uid = DECL_UID (var);
- clear_call_clobbered (var);
- if ((v_ann = var_ann (var)))
- ggc_free (v_ann);
- var->base.ann = NULL;
- gcc_assert (DECL_P (var));
+ gcc_checking_assert (TREE_CODE (var) == VAR_DECL
+ || TREE_CODE (var) == PARM_DECL
+ || TREE_CODE (var) == RESULT_DECL);
+
+ gcc_checking_assert (!is_global_var (var));
+
+ v_ann = var_ann (var);
+ ggc_free (v_ann);
+ *DECL_VAR_ANN_PTR (var) = NULL;
+
in.uid = uid;
loc = htab_find_slot_with_hash (gimple_referenced_vars (cfun), &in, uid,
NO_INSERT);
}
-/* Return the virtual variable associated to the non-scalar variable VAR. */
-
-tree
-get_virtual_var (tree var)
-{
- STRIP_NOPS (var);
-
- if (TREE_CODE (var) == SSA_NAME)
- var = SSA_NAME_VAR (var);
-
- while (TREE_CODE (var) == REALPART_EXPR || TREE_CODE (var) == IMAGPART_EXPR
- || handled_component_p (var))
- var = TREE_OPERAND (var, 0);
-
- /* Treating GIMPLE registers as virtual variables makes no sense.
- Also complain if we couldn't extract a _DECL out of the original
- expression. */
- gcc_assert (SSA_VAR_P (var));
- gcc_assert (!is_gimple_reg (var));
-
- return var;
-}
-
-/* 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_symbols_for_renaming (tree stmt)
-{
- tree op;
- ssa_op_iter iter;
-
- update_stmt (stmt);
-
- /* 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. */
-
-static tree
-find_new_referenced_vars_1 (tree *tp, int *walk_subtrees,
- void *data ATTRIBUTE_UNUSED)
-{
- tree t = *tp;
-
- if (TREE_CODE (t) == VAR_DECL && !var_ann (t))
- {
- add_referenced_var (t);
- mark_sym_for_renaming (t);
- }
-
- if (IS_TYPE_OR_DECL_P (t))
- *walk_subtrees = 0;
-
- return NULL;
-}
-
-void
-find_new_referenced_vars (tree *stmt_p)
-{
- walk_tree (stmt_p, find_new_referenced_vars_1, NULL, NULL);
-}
-
-
/* 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
HOST_WIDE_INT bitsize = -1;
HOST_WIDE_INT maxsize = -1;
tree size_tree = NULL_TREE;
- HOST_WIDE_INT bit_offset = 0;
+ double_int bit_offset = double_int_zero;
+ HOST_WIDE_INT hbit_offset;
bool seen_variable_array_ref = false;
-
- gcc_assert (!SSA_VAR_P (exp));
+ tree base_type;
/* First get the final access size from just the outermost expression. */
if (TREE_CODE (exp) == COMPONENT_REF)
size_tree = DECL_SIZE (TREE_OPERAND (exp, 1));
else if (TREE_CODE (exp) == BIT_FIELD_REF)
size_tree = TREE_OPERAND (exp, 1);
- else
+ else if (!VOID_TYPE_P (TREE_TYPE (exp)))
{
enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
if (mode == BLKmode)
and find the ultimate containing object. */
while (1)
{
+ base_type = TREE_TYPE (exp);
+
switch (TREE_CODE (exp))
{
case BIT_FIELD_REF:
- bit_offset += tree_low_cst (TREE_OPERAND (exp, 2), 0);
+ bit_offset
+ = double_int_add (bit_offset,
+ tree_to_double_int (TREE_OPERAND (exp, 2)));
break;
case COMPONENT_REF:
if (this_offset && TREE_CODE (this_offset) == INTEGER_CST)
{
- 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);
+ double_int doffset = tree_to_double_int (this_offset);
+ doffset = double_int_lshift (doffset,
+ BITS_PER_UNIT == 8
+ ? 3 : exact_log2 (BITS_PER_UNIT),
+ HOST_BITS_PER_DOUBLE_INT, true);
+ doffset = double_int_add (doffset,
+ tree_to_double_int
+ (DECL_FIELD_BIT_OFFSET (field)));
+ bit_offset = double_int_add (bit_offset, doffset);
+
+ /* 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 = DECL_CHAIN (field);
+ while (next && TREE_CODE (next) != FIELD_DECL)
+ next = DECL_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)
+ && double_int_fits_in_shwi_p (doffset))
+ maxsize += ((TREE_INT_CST_LOW (ssize)
+ - TREE_INT_CST_LOW (fsize))
+ * BITS_PER_UNIT
+ - double_int_to_shwi (doffset));
+ else
+ maxsize = -1;
+ }
+ }
}
else
{
tree csize = TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp, 0)));
/* We need to adjust maxsize to the whole structure bitsize.
- But we can subtract any constant offset seen sofar,
+ But we can subtract any constant offset seen so far,
because that would get us out of the structure otherwise. */
- if (maxsize != -1 && csize && host_integerp (csize, 1))
- maxsize = TREE_INT_CST_LOW (csize) - bit_offset;
+ if (maxsize != -1
+ && csize
+ && host_integerp (csize, 1)
+ && double_int_fits_in_shwi_p (bit_offset))
+ maxsize = TREE_INT_CST_LOW (csize)
+ - double_int_to_shwi (bit_offset);
else
maxsize = -1;
}
case ARRAY_RANGE_REF:
{
tree index = TREE_OPERAND (exp, 1);
- tree low_bound = array_ref_low_bound (exp);
- tree unit_size = array_ref_element_size (exp);
+ tree low_bound, unit_size;
/* If the resulting bit-offset is constant, track it. */
- if (host_integerp (index, 0)
- && host_integerp (low_bound, 0)
- && host_integerp (unit_size, 1))
+ if (TREE_CODE (index) == INTEGER_CST
+ && (low_bound = array_ref_low_bound (exp),
+ TREE_CODE (low_bound) == INTEGER_CST)
+ && (unit_size = array_ref_element_size (exp),
+ TREE_CODE (unit_size) == INTEGER_CST))
{
- 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;
+ double_int doffset
+ = double_int_sext
+ (double_int_sub (TREE_INT_CST (index),
+ TREE_INT_CST (low_bound)),
+ TYPE_PRECISION (TREE_TYPE (index)));
+ doffset = double_int_mul (doffset,
+ tree_to_double_int (unit_size));
+ doffset = double_int_lshift (doffset,
+ BITS_PER_UNIT == 8
+ ? 3 : exact_log2 (BITS_PER_UNIT),
+ HOST_BITS_PER_DOUBLE_INT, true);
+ bit_offset = double_int_add (bit_offset, doffset);
/* An array ref with a constant index up in the structure
hierarchy will constrain the size of any variable array ref
{
tree asize = TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp, 0)));
/* We need to adjust maxsize to the whole array bitsize.
- But we can subtract any constant offset seen sofar,
+ But we can subtract any constant offset seen so far,
because that would get us outside of the array otherwise. */
- if (maxsize != -1 && asize && host_integerp (asize, 1))
- maxsize = TREE_INT_CST_LOW (asize) - bit_offset;
+ if (maxsize != -1
+ && asize
+ && host_integerp (asize, 1)
+ && double_int_fits_in_shwi_p (bit_offset))
+ maxsize = TREE_INT_CST_LOW (asize)
+ - double_int_to_shwi (bit_offset);
else
maxsize = -1;
break;
case IMAGPART_EXPR:
- bit_offset += bitsize;
+ bit_offset
+ = double_int_add (bit_offset, uhwi_to_double_int (bitsize));
break;
case VIEW_CONVERT_EXPR:
- /* ??? We probably should give up here and bail out. */
break;
+ case MEM_REF:
+ /* Hand back the decl for MEM[&decl, off]. */
+ if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR)
+ {
+ if (integer_zerop (TREE_OPERAND (exp, 1)))
+ exp = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
+ else
+ {
+ double_int off = mem_ref_offset (exp);
+ off = double_int_lshift (off,
+ BITS_PER_UNIT == 8
+ ? 3 : exact_log2 (BITS_PER_UNIT),
+ HOST_BITS_PER_DOUBLE_INT, true);
+ off = double_int_add (off, bit_offset);
+ if (double_int_fits_in_shwi_p (off))
+ {
+ bit_offset = off;
+ exp = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
+ }
+ }
+ }
+ goto done;
+
+ case TARGET_MEM_REF:
+ /* Hand back the decl for MEM[&decl, off]. */
+ if (TREE_CODE (TMR_BASE (exp)) == ADDR_EXPR)
+ {
+ /* Via the variable index or index2 we can reach the
+ whole object. */
+ if (TMR_INDEX (exp) || TMR_INDEX2 (exp))
+ {
+ exp = TREE_OPERAND (TMR_BASE (exp), 0);
+ bit_offset = double_int_zero;
+ maxsize = -1;
+ goto done;
+ }
+ if (integer_zerop (TMR_OFFSET (exp)))
+ exp = TREE_OPERAND (TMR_BASE (exp), 0);
+ else
+ {
+ double_int off = mem_ref_offset (exp);
+ off = double_int_lshift (off,
+ BITS_PER_UNIT == 8
+ ? 3 : exact_log2 (BITS_PER_UNIT),
+ HOST_BITS_PER_DOUBLE_INT, true);
+ off = double_int_add (off, bit_offset);
+ if (double_int_fits_in_shwi_p (off))
+ {
+ bit_offset = off;
+ exp = TREE_OPERAND (TMR_BASE (exp), 0);
+ }
+ }
+ }
+ goto done;
+
default:
goto done;
}
}
done:
+ if (!double_int_fits_in_shwi_p (bit_offset))
+ {
+ *poffset = 0;
+ *psize = bitsize;
+ *pmax_size = -1;
+
+ return exp;
+ }
+
+ hbit_offset = double_int_to_shwi (bit_offset);
+
/* We need to deal with variable arrays ending structures such as
struct { int length; int a[1]; } x; x.a[d]
struct { struct { int a; int b; } a[1]; } x; x.a[d].a
struct { struct { int a[1]; } a[1]; } x; x.a[0][d], x.a[d][0]
+ struct { int len; union { int a[1]; struct X x; } u; } x; x.u.a[d]
where we do not know maxsize for variable index accesses to
the array. The simplest way to conservatively deal with this
is to punt in the case that offset + maxsize reaches the
- base type boundary. */
+ base type boundary. This needs to include possible trailing padding
+ 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))))
+ && (!host_integerp (TYPE_SIZE (base_type), 1)
+ || (hbit_offset + maxsize
+ == (signed) TREE_INT_CST_LOW (TYPE_SIZE (base_type)))))
maxsize = -1;
+ /* In case of a decl or constant base object we can do better. */
+
+ 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)) - hbit_offset;
+ }
+ else if (CONSTANT_CLASS_P (exp))
+ {
+ /* If maxsize is unknown adjust it according to the size of the
+ base type constant. */
+ if (maxsize == -1
+ && host_integerp (TYPE_SIZE (TREE_TYPE (exp)), 1))
+ maxsize = TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (exp))) - hbit_offset;
+ }
+
/* ??? 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 = bit_offset;
+ *poffset = hbit_offset;
*psize = bitsize;
*pmax_size = maxsize;
return exp;
}
+/* Returns the base object and a constant BITS_PER_UNIT offset in *POFFSET that
+ denotes the starting address of the memory access EXP.
+ Returns NULL_TREE if the offset is not constant or any component
+ is not BITS_PER_UNIT-aligned. */
+
+tree
+get_addr_base_and_unit_offset (tree exp, HOST_WIDE_INT *poffset)
+{
+ return get_addr_base_and_unit_offset_1 (exp, poffset, NULL);
+}
+
/* Returns true if STMT references an SSA_NAME that has
SSA_NAME_OCCURS_IN_ABNORMAL_PHI set, otherwise false. */
bool
-stmt_references_abnormal_ssa_name (tree stmt)
+stmt_references_abnormal_ssa_name (gimple stmt)
{
ssa_op_iter oi;
use_operand_p use_p;
return false;
}
-/* Return true, if the two memory references REF1 and REF2 may alias. */
-
-bool
-refs_may_alias_p (tree ref1, tree ref2)
+/* Pair of tree and a sorting index, for dump_enumerated_decls. */
+struct GTY(()) numbered_tree_d
{
- tree base1, base2;
- HOST_WIDE_INT offset1 = 0, offset2 = 0;
- HOST_WIDE_INT size1 = -1, size2 = -1;
- HOST_WIDE_INT max_size1 = -1, max_size2 = -1;
- bool strict_aliasing_applies;
-
- gcc_assert ((SSA_VAR_P (ref1)
- || handled_component_p (ref1)
- || INDIRECT_REF_P (ref1)
- || TREE_CODE (ref1) == TARGET_MEM_REF)
- && (SSA_VAR_P (ref2)
- || handled_component_p (ref2)
- || INDIRECT_REF_P (ref2)
- || TREE_CODE (ref2) == TARGET_MEM_REF));
-
- /* Defer to TBAA if possible. */
- if (flag_strict_aliasing
- && !alias_sets_conflict_p (get_alias_set (ref1), get_alias_set (ref2)))
- return false;
-
- /* Decompose the references into their base objects and the access. */
- base1 = ref1;
- if (handled_component_p (ref1))
- base1 = get_ref_base_and_extent (ref1, &offset1, &size1, &max_size1);
- base2 = ref2;
- if (handled_component_p (ref2))
- base2 = get_ref_base_and_extent (ref2, &offset2, &size2, &max_size2);
-
- /* If both references are based on different variables, they cannot alias.
- If both references are based on the same variable, they cannot alias if
- if the accesses do not overlap. */
- if (SSA_VAR_P (base1)
- && SSA_VAR_P (base2))
- {
- if (!operand_equal_p (base1, base2, 0))
- return false;
- return ranges_overlap_p (offset1, max_size1, offset2, max_size2);
- }
-
- /* If one base is a ref-all pointer weird things are allowed. */
- strict_aliasing_applies = (flag_strict_aliasing
- && get_alias_set (base1) != 0
- && get_alias_set (base2) != 0);
-
- /* If both references are through the same type, or if strict aliasing
- doesn't apply they are through two same pointers, they do not alias
- if the accesses do not overlap. */
- if ((strict_aliasing_applies
- && (TYPE_MAIN_VARIANT (TREE_TYPE (base1))
- == TYPE_MAIN_VARIANT (TREE_TYPE (base2))))
- || (TREE_CODE (base1) == INDIRECT_REF
- && TREE_CODE (base2) == INDIRECT_REF
- && operand_equal_p (TREE_OPERAND (base1, 0),
- TREE_OPERAND (base2, 0), 0)))
- return ranges_overlap_p (offset1, max_size1, offset2, max_size2);
-
- /* If both are component references through pointers try to find a
- common base and apply offset based disambiguation. This handles
- for example
- struct A { int i; int j; } *q;
- struct B { struct A a; int k; } *p;
- disambiguating q->i and p->a.j. */
- if (strict_aliasing_applies
- && (TREE_CODE (base1) == INDIRECT_REF
- || TREE_CODE (base2) == INDIRECT_REF)
- && handled_component_p (ref1)
- && handled_component_p (ref2))
- {
- tree *refp;
- /* Now search for the type of base1 in the access path of ref2. This
- would be a common base for doing offset based disambiguation on. */
- refp = &ref2;
- while (handled_component_p (*refp)
- /* Note that the following is only conservative if there are
- never copies of types appearing as sub-structures. */
- && (TYPE_MAIN_VARIANT (TREE_TYPE (*refp))
- != TYPE_MAIN_VARIANT (TREE_TYPE (base1))))
- refp = &TREE_OPERAND (*refp, 0);
- if (TYPE_MAIN_VARIANT (TREE_TYPE (*refp))
- == TYPE_MAIN_VARIANT (TREE_TYPE (base1)))
- {
- HOST_WIDE_INT offadj, sztmp, msztmp;
- get_ref_base_and_extent (*refp, &offadj, &sztmp, &msztmp);
- offset2 -= offadj;
- return ranges_overlap_p (offset1, max_size1, offset2, max_size2);
- }
- /* The other way around. */
- refp = &ref1;
- while (handled_component_p (*refp)
- && (TYPE_MAIN_VARIANT (TREE_TYPE (*refp))
- != TYPE_MAIN_VARIANT (TREE_TYPE (base2))))
- refp = &TREE_OPERAND (*refp, 0);
- if (TYPE_MAIN_VARIANT (TREE_TYPE (*refp))
- == TYPE_MAIN_VARIANT (TREE_TYPE (base2)))
- {
- HOST_WIDE_INT offadj, sztmp, msztmp;
- get_ref_base_and_extent (*refp, &offadj, &sztmp, &msztmp);
- offset1 -= offadj;
- return ranges_overlap_p (offset1, max_size1, offset2, max_size2);
- }
- /* If we can be sure to catch all equivalent types in the search
- for the common base then we could return false here. In that
- case we would be able to disambiguate q->i and p->k. */
- }
+ tree t;
+ int num;
+};
+typedef struct numbered_tree_d numbered_tree;
- return true;
-}
+DEF_VEC_O (numbered_tree);
+DEF_VEC_ALLOC_O (numbered_tree, heap);
-/* Given a stmt STMT that references memory, return the single stmt
- that is reached by following the VUSE -> VDEF link. Returns
- NULL_TREE, if there is no single stmt that defines all VUSEs of
- STMT.
- Note that for a stmt with a single virtual operand this may return
- a PHI node as well. Note that if all VUSEs are default definitions
- this function will return an empty statement. */
+/* Compare two declarations references by their DECL_UID / sequence number.
+ Called via qsort. */
-tree
-get_single_def_stmt (tree stmt)
+static int
+compare_decls_by_uid (const void *pa, const void *pb)
{
- tree def_stmt = NULL_TREE;
- tree use;
- ssa_op_iter iter;
+ const numbered_tree *nt_a = ((const numbered_tree *)pa);
+ const numbered_tree *nt_b = ((const numbered_tree *)pb);
- FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_VIRTUAL_USES)
- {
- tree tmp = SSA_NAME_DEF_STMT (use);
-
- /* ??? This is too simplistic for multiple virtual operands
- reaching different PHI nodes of the same basic blocks or for
- reaching all default definitions. */
- if (def_stmt
- && def_stmt != tmp
- && !(IS_EMPTY_STMT (def_stmt)
- && IS_EMPTY_STMT (tmp)))
- return NULL_TREE;
-
- def_stmt = tmp;
- }
-
- return def_stmt;
+ if (DECL_UID (nt_a->t) != DECL_UID (nt_b->t))
+ return DECL_UID (nt_a->t) - DECL_UID (nt_b->t);
+ return nt_a->num - nt_b->num;
}
-/* Given a PHI node of virtual operands, tries to eliminate cyclic
- reached definitions if they do not alias REF and returns the
- defining statement of the single virtual operand that flows in
- from a non-backedge. Returns NULL_TREE if such statement within
- the above conditions cannot be found. */
+/* Called via walk_gimple_stmt / walk_gimple_op by dump_enumerated_decls. */
+static tree
+dump_enumerated_decls_push (tree *tp, int *walk_subtrees, void *data)
+{
+ struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
+ VEC (numbered_tree, heap) **list = (VEC (numbered_tree, heap) **) &wi->info;
+ numbered_tree nt;
+
+ if (!DECL_P (*tp))
+ return NULL_TREE;
+ nt.t = *tp;
+ nt.num = VEC_length (numbered_tree, *list);
+ VEC_safe_push (numbered_tree, heap, *list, &nt);
+ *walk_subtrees = 0;
+ return NULL_TREE;
+}
-tree
-get_single_def_stmt_from_phi (tree ref, tree phi)
+/* Find all the declarations used by the current function, sort them by uid,
+ and emit the sorted list. Each declaration is tagged with a sequence
+ number indicating when it was found during statement / tree walking,
+ so that TDF_NOUID comparisons of anonymous declarations are still
+ meaningful. Where a declaration was encountered more than once, we
+ emit only the sequence number of the first encounter.
+ FILE is the dump file where to output the list and FLAGS is as in
+ print_generic_expr. */
+void
+dump_enumerated_decls (FILE *file, int flags)
{
- tree def_arg = NULL_TREE;
- int i;
+ basic_block bb;
+ struct walk_stmt_info wi;
+ VEC (numbered_tree, heap) *decl_list = VEC_alloc (numbered_tree, heap, 40);
- /* Find the single PHI argument that is not flowing in from a
- back edge and verify that the loop-carried definitions do
- not alias the reference we look for. */
- for (i = 0; i < PHI_NUM_ARGS (phi); ++i)
+ memset (&wi, '\0', sizeof (wi));
+ wi.info = (void*) decl_list;
+ FOR_EACH_BB (bb)
{
- tree arg = PHI_ARG_DEF (phi, i);
- tree def_stmt;
+ gimple_stmt_iterator gsi;
- if (!(PHI_ARG_EDGE (phi, i)->flags & EDGE_DFS_BACK))
- {
- /* Multiple non-back edges? Do not try to handle this. */
- if (def_arg)
- return NULL_TREE;
- def_arg = arg;
- continue;
- }
+ for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
+ if (!is_gimple_debug (gsi_stmt (gsi)))
+ walk_gimple_stmt (&gsi, NULL, dump_enumerated_decls_push, &wi);
+ }
+ decl_list = (VEC (numbered_tree, heap) *) wi.info;
+ VEC_qsort (numbered_tree, decl_list, compare_decls_by_uid);
+ if (VEC_length (numbered_tree, decl_list))
+ {
+ unsigned ix;
+ numbered_tree *ntp;
+ tree last = NULL_TREE;
- /* Follow the definitions back to the original PHI node. Bail
- out once a definition is found that may alias REF. */
- def_stmt = SSA_NAME_DEF_STMT (arg);
- do
+ fprintf (file, "Declarations used by %s, sorted by DECL_UID:\n",
+ current_function_name ());
+ FOR_EACH_VEC_ELT (numbered_tree, decl_list, ix, ntp)
{
- if (TREE_CODE (def_stmt) != GIMPLE_MODIFY_STMT
- || refs_may_alias_p (ref, GIMPLE_STMT_OPERAND (def_stmt, 0)))
- return NULL_TREE;
- /* ??? This will only work, reaching the PHI node again if
- there is a single virtual operand on def_stmt. */
- def_stmt = get_single_def_stmt (def_stmt);
- if (!def_stmt)
- return NULL_TREE;
+ if (ntp->t == last)
+ continue;
+ fprintf (file, "%d: ", ntp->num);
+ print_generic_decl (file, ntp->t, flags);
+ fprintf (file, "\n");
+ last = ntp->t;
}
- while (def_stmt != phi);
}
-
- return SSA_NAME_DEF_STMT (def_arg);
+ VEC_free (numbered_tree, heap, decl_list);
}
-/* Return the single reference statement defining all virtual uses
- on STMT or NULL_TREE, if there are multiple defining statements.
- Take into account only definitions that alias REF if following
- back-edges when looking through a loop PHI node. */
-
-tree
-get_single_def_stmt_with_phi (tree ref, tree stmt)
-{
- switch (NUM_SSA_OPERANDS (stmt, SSA_OP_VIRTUAL_USES))
- {
- case 0:
- gcc_unreachable ();
-
- case 1:
- {
- tree def_stmt = SSA_NAME_DEF_STMT (SINGLE_SSA_TREE_OPERAND
- (stmt, SSA_OP_VIRTUAL_USES));
- /* We can handle lookups over PHI nodes only for a single
- virtual operand. */
- if (TREE_CODE (def_stmt) == PHI_NODE)
- return get_single_def_stmt_from_phi (ref, def_stmt);
- return def_stmt;
- }
-
- default:
- return get_single_def_stmt (stmt);
- }
-}
projects / gcc.git / blobdiff