/* Data flow functions for trees.
|
/* 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 Free Software Foundation, Inc.
|
Contributed by Diego Novillo <dnovillo@redhat.com>
|
Contributed by Diego Novillo <dnovillo@redhat.com>
|
|
|
This file is part of GCC.
|
This file is part of GCC.
|
|
|
GCC is free software; you can redistribute it and/or modify
|
GCC is free software; you can redistribute it and/or modify
|
it under the terms of the GNU General Public License as published by
|
it under the terms of the GNU General Public License as published by
|
the Free Software Foundation; either version 3, or (at your option)
|
the Free Software Foundation; either version 3, or (at your option)
|
any later version.
|
any later version.
|
|
|
GCC is distributed in the hope that it will be useful,
|
GCC is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with GCC; see the file COPYING3. If not see
|
along with GCC; see the file COPYING3. If not see
|
<http://www.gnu.org/licenses/>. */
|
<http://www.gnu.org/licenses/>. */
|
|
|
#include "config.h"
|
#include "config.h"
|
#include "system.h"
|
#include "system.h"
|
#include "coretypes.h"
|
#include "coretypes.h"
|
#include "tm.h"
|
#include "tm.h"
|
#include "hashtab.h"
|
#include "hashtab.h"
|
#include "pointer-set.h"
|
#include "pointer-set.h"
|
#include "tree.h"
|
#include "tree.h"
|
#include "rtl.h"
|
#include "rtl.h"
|
#include "tm_p.h"
|
#include "tm_p.h"
|
#include "hard-reg-set.h"
|
#include "hard-reg-set.h"
|
#include "basic-block.h"
|
#include "basic-block.h"
|
#include "output.h"
|
#include "output.h"
|
#include "timevar.h"
|
#include "timevar.h"
|
#include "expr.h"
|
#include "expr.h"
|
#include "ggc.h"
|
#include "ggc.h"
|
#include "langhooks.h"
|
#include "langhooks.h"
|
#include "flags.h"
|
#include "flags.h"
|
#include "function.h"
|
#include "function.h"
|
#include "diagnostic.h"
|
#include "diagnostic.h"
|
#include "tree-dump.h"
|
#include "tree-dump.h"
|
#include "tree-gimple.h"
|
#include "tree-gimple.h"
|
#include "tree-flow.h"
|
#include "tree-flow.h"
|
#include "tree-inline.h"
|
#include "tree-inline.h"
|
#include "tree-pass.h"
|
#include "tree-pass.h"
|
#include "convert.h"
|
#include "convert.h"
|
#include "params.h"
|
#include "params.h"
|
#include "cgraph.h"
|
#include "cgraph.h"
|
|
|
/* Build and maintain data flow information for trees. */
|
/* Build and maintain data flow information for trees. */
|
|
|
/* Counters used to display DFA and SSA statistics. */
|
/* Counters used to display DFA and SSA statistics. */
|
struct dfa_stats_d
|
struct dfa_stats_d
|
{
|
{
|
long num_stmt_anns;
|
long num_stmt_anns;
|
long num_var_anns;
|
long num_var_anns;
|
long num_defs;
|
long num_defs;
|
long num_uses;
|
long num_uses;
|
long num_phis;
|
long num_phis;
|
long num_phi_args;
|
long num_phi_args;
|
int max_num_phi_args;
|
int max_num_phi_args;
|
long num_v_may_defs;
|
long num_v_may_defs;
|
long num_vuses;
|
long num_vuses;
|
long num_v_must_defs;
|
long num_v_must_defs;
|
};
|
};
|
|
|
|
|
/* Local functions. */
|
/* Local functions. */
|
static void collect_dfa_stats (struct dfa_stats_d *);
|
static void collect_dfa_stats (struct dfa_stats_d *);
|
static tree collect_dfa_stats_r (tree *, int *, void *);
|
static tree collect_dfa_stats_r (tree *, int *, void *);
|
static tree find_vars_r (tree *, int *, void *);
|
static tree find_vars_r (tree *, int *, void *);
|
|
|
|
|
/* Global declarations. */
|
/* Global declarations. */
|
|
|
/* Array of all variables referenced in the function. */
|
/* Array of all variables referenced in the function. */
|
htab_t referenced_vars;
|
htab_t referenced_vars;
|
|
|
/* Default definition for this symbols. If set for symbol, it
|
/* Default definition for this symbols. If set for symbol, it
|
means that the first reference to this variable in the function is a
|
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
|
USE or a VUSE. In those cases, the SSA renamer creates an SSA name
|
for this variable with an empty defining statement. */
|
for this variable with an empty defining statement. */
|
htab_t default_defs;
|
htab_t default_defs;
|
|
|
|
|
/*---------------------------------------------------------------------------
|
/*---------------------------------------------------------------------------
|
Dataflow analysis (DFA) routines
|
Dataflow analysis (DFA) routines
|
---------------------------------------------------------------------------*/
|
---------------------------------------------------------------------------*/
|
/* Find all the variables referenced in the function. This function
|
/* Find all the variables referenced in the function. This function
|
builds the global arrays REFERENCED_VARS and CALL_CLOBBERED_VARS.
|
builds the global arrays REFERENCED_VARS and CALL_CLOBBERED_VARS.
|
|
|
Note that this function does not look for statement operands, it simply
|
Note that this function does not look for statement operands, it simply
|
determines what variables are referenced in the program and detects
|
determines what variables are referenced in the program and detects
|
various attributes for each variable used by alias analysis and the
|
various attributes for each variable used by alias analysis and the
|
optimizer. */
|
optimizer. */
|
|
|
static unsigned int
|
static unsigned int
|
find_referenced_vars (void)
|
find_referenced_vars (void)
|
{
|
{
|
basic_block bb;
|
basic_block bb;
|
block_stmt_iterator si;
|
block_stmt_iterator si;
|
|
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
for (si = bsi_start (bb); !bsi_end_p (si); bsi_next (&si))
|
for (si = bsi_start (bb); !bsi_end_p (si); bsi_next (&si))
|
{
|
{
|
tree *stmt_p = bsi_stmt_ptr (si);
|
tree *stmt_p = bsi_stmt_ptr (si);
|
walk_tree (stmt_p, find_vars_r, NULL, NULL);
|
walk_tree (stmt_p, find_vars_r, NULL, NULL);
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
struct tree_opt_pass pass_referenced_vars =
|
struct tree_opt_pass pass_referenced_vars =
|
{
|
{
|
NULL, /* name */
|
NULL, /* name */
|
NULL, /* gate */
|
NULL, /* gate */
|
find_referenced_vars, /* execute */
|
find_referenced_vars, /* execute */
|
NULL, /* sub */
|
NULL, /* sub */
|
NULL, /* next */
|
NULL, /* next */
|
0, /* static_pass_number */
|
0, /* static_pass_number */
|
TV_FIND_REFERENCED_VARS, /* tv_id */
|
TV_FIND_REFERENCED_VARS, /* tv_id */
|
PROP_gimple_leh | PROP_cfg, /* properties_required */
|
PROP_gimple_leh | PROP_cfg, /* properties_required */
|
PROP_referenced_vars, /* properties_provided */
|
PROP_referenced_vars, /* properties_provided */
|
0, /* properties_destroyed */
|
0, /* properties_destroyed */
|
0, /* todo_flags_start */
|
0, /* todo_flags_start */
|
0, /* todo_flags_finish */
|
0, /* todo_flags_finish */
|
0 /* letter */
|
0 /* letter */
|
};
|
};
|
|
|
|
|
/*---------------------------------------------------------------------------
|
/*---------------------------------------------------------------------------
|
Manage annotations
|
Manage annotations
|
---------------------------------------------------------------------------*/
|
---------------------------------------------------------------------------*/
|
/* Create a new annotation for a _DECL node T. */
|
/* Create a new annotation for a _DECL node T. */
|
|
|
var_ann_t
|
var_ann_t
|
create_var_ann (tree t)
|
create_var_ann (tree t)
|
{
|
{
|
var_ann_t ann;
|
var_ann_t ann;
|
|
|
gcc_assert (t);
|
gcc_assert (t);
|
gcc_assert (DECL_P (t));
|
gcc_assert (DECL_P (t));
|
gcc_assert (!t->common.ann || t->common.ann->common.type == VAR_ANN);
|
gcc_assert (!t->common.ann || t->common.ann->common.type == VAR_ANN);
|
|
|
ann = GGC_CNEW (struct var_ann_d);
|
ann = GGC_CNEW (struct var_ann_d);
|
|
|
ann->common.type = VAR_ANN;
|
ann->common.type = VAR_ANN;
|
|
|
t->common.ann = (tree_ann_t) ann;
|
t->common.ann = (tree_ann_t) ann;
|
|
|
return ann;
|
return ann;
|
}
|
}
|
|
|
/* Create a new annotation for a FUNCTION_DECL node T. */
|
/* Create a new annotation for a FUNCTION_DECL node T. */
|
|
|
function_ann_t
|
function_ann_t
|
create_function_ann (tree t)
|
create_function_ann (tree t)
|
{
|
{
|
function_ann_t ann;
|
function_ann_t ann;
|
|
|
gcc_assert (t);
|
gcc_assert (t);
|
gcc_assert (TREE_CODE (t) == FUNCTION_DECL);
|
gcc_assert (TREE_CODE (t) == FUNCTION_DECL);
|
gcc_assert (!t->common.ann || t->common.ann->common.type == FUNCTION_ANN);
|
gcc_assert (!t->common.ann || t->common.ann->common.type == FUNCTION_ANN);
|
|
|
ann = ggc_alloc (sizeof (*ann));
|
ann = ggc_alloc (sizeof (*ann));
|
memset ((void *) ann, 0, sizeof (*ann));
|
memset ((void *) ann, 0, sizeof (*ann));
|
|
|
ann->common.type = FUNCTION_ANN;
|
ann->common.type = FUNCTION_ANN;
|
|
|
t->common.ann = (tree_ann_t) ann;
|
t->common.ann = (tree_ann_t) ann;
|
|
|
return ann;
|
return ann;
|
}
|
}
|
|
|
/* Create a new annotation for a statement node T. */
|
/* Create a new annotation for a statement node T. */
|
|
|
stmt_ann_t
|
stmt_ann_t
|
create_stmt_ann (tree t)
|
create_stmt_ann (tree t)
|
{
|
{
|
stmt_ann_t ann;
|
stmt_ann_t ann;
|
|
|
gcc_assert (is_gimple_stmt (t));
|
gcc_assert (is_gimple_stmt (t));
|
gcc_assert (!t->common.ann || t->common.ann->common.type == STMT_ANN);
|
gcc_assert (!t->common.ann || t->common.ann->common.type == STMT_ANN);
|
|
|
ann = GGC_CNEW (struct stmt_ann_d);
|
ann = GGC_CNEW (struct stmt_ann_d);
|
|
|
ann->common.type = STMT_ANN;
|
ann->common.type = STMT_ANN;
|
|
|
/* Since we just created the annotation, mark the statement modified. */
|
/* Since we just created the annotation, mark the statement modified. */
|
ann->modified = true;
|
ann->modified = true;
|
|
|
t->common.ann = (tree_ann_t) ann;
|
t->common.ann = (tree_ann_t) ann;
|
|
|
return ann;
|
return ann;
|
}
|
}
|
|
|
/* Create a new annotation for a tree T. */
|
/* Create a new annotation for a tree T. */
|
|
|
tree_ann_common_t
|
tree_ann_common_t
|
create_tree_common_ann (tree t)
|
create_tree_common_ann (tree t)
|
{
|
{
|
tree_ann_common_t ann;
|
tree_ann_common_t ann;
|
|
|
gcc_assert (t);
|
gcc_assert (t);
|
gcc_assert (!t->common.ann || t->common.ann->common.type == TREE_ANN_COMMON);
|
gcc_assert (!t->common.ann || t->common.ann->common.type == TREE_ANN_COMMON);
|
|
|
ann = GGC_CNEW (struct tree_ann_common_d);
|
ann = GGC_CNEW (struct tree_ann_common_d);
|
|
|
ann->type = TREE_ANN_COMMON;
|
ann->type = TREE_ANN_COMMON;
|
t->common.ann = (tree_ann_t) ann;
|
t->common.ann = (tree_ann_t) ann;
|
|
|
return ann;
|
return ann;
|
}
|
}
|
|
|
/* Build a temporary. Make sure and register it to be renamed. */
|
/* Build a temporary. Make sure and register it to be renamed. */
|
|
|
tree
|
tree
|
make_rename_temp (tree type, const char *prefix)
|
make_rename_temp (tree type, const char *prefix)
|
{
|
{
|
tree t = create_tmp_var (type, prefix);
|
tree t = create_tmp_var (type, prefix);
|
|
|
if (TREE_CODE (type) == COMPLEX_TYPE)
|
if (TREE_CODE (type) == COMPLEX_TYPE)
|
DECL_COMPLEX_GIMPLE_REG_P (t) = 1;
|
DECL_COMPLEX_GIMPLE_REG_P (t) = 1;
|
|
|
if (referenced_vars)
|
if (referenced_vars)
|
{
|
{
|
add_referenced_var (t);
|
add_referenced_var (t);
|
mark_sym_for_renaming (t);
|
mark_sym_for_renaming (t);
|
}
|
}
|
|
|
return t;
|
return t;
|
}
|
}
|
|
|
|
|
|
|
/*---------------------------------------------------------------------------
|
/*---------------------------------------------------------------------------
|
Debugging functions
|
Debugging functions
|
---------------------------------------------------------------------------*/
|
---------------------------------------------------------------------------*/
|
/* Dump the list of all the referenced variables in the current function to
|
/* Dump the list of all the referenced variables in the current function to
|
FILE. */
|
FILE. */
|
|
|
void
|
void
|
dump_referenced_vars (FILE *file)
|
dump_referenced_vars (FILE *file)
|
{
|
{
|
tree var;
|
tree var;
|
referenced_var_iterator rvi;
|
referenced_var_iterator rvi;
|
|
|
fprintf (file, "\nReferenced variables in %s: %u\n\n",
|
fprintf (file, "\nReferenced variables in %s: %u\n\n",
|
get_name (current_function_decl), (unsigned) num_referenced_vars);
|
get_name (current_function_decl), (unsigned) num_referenced_vars);
|
|
|
FOR_EACH_REFERENCED_VAR (var, rvi)
|
FOR_EACH_REFERENCED_VAR (var, rvi)
|
{
|
{
|
fprintf (file, "Variable: ");
|
fprintf (file, "Variable: ");
|
dump_variable (file, var);
|
dump_variable (file, var);
|
fprintf (file, "\n");
|
fprintf (file, "\n");
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Dump the list of all the referenced variables to stderr. */
|
/* Dump the list of all the referenced variables to stderr. */
|
|
|
void
|
void
|
debug_referenced_vars (void)
|
debug_referenced_vars (void)
|
{
|
{
|
dump_referenced_vars (stderr);
|
dump_referenced_vars (stderr);
|
}
|
}
|
|
|
|
|
/* Dump sub-variables for VAR to FILE. */
|
/* Dump sub-variables for VAR to FILE. */
|
|
|
void
|
void
|
dump_subvars_for (FILE *file, tree var)
|
dump_subvars_for (FILE *file, tree var)
|
{
|
{
|
subvar_t sv = get_subvars_for_var (var);
|
subvar_t sv = get_subvars_for_var (var);
|
|
|
if (!sv)
|
if (!sv)
|
return;
|
return;
|
|
|
fprintf (file, "{ ");
|
fprintf (file, "{ ");
|
|
|
for (; sv; sv = sv->next)
|
for (; sv; sv = sv->next)
|
{
|
{
|
print_generic_expr (file, sv->var, dump_flags);
|
print_generic_expr (file, sv->var, dump_flags);
|
fprintf (file, " ");
|
fprintf (file, " ");
|
}
|
}
|
|
|
fprintf (file, "}");
|
fprintf (file, "}");
|
}
|
}
|
|
|
|
|
/* Dumb sub-variables for VAR to stderr. */
|
/* Dumb sub-variables for VAR to stderr. */
|
|
|
void
|
void
|
debug_subvars_for (tree var)
|
debug_subvars_for (tree var)
|
{
|
{
|
dump_subvars_for (stderr, var);
|
dump_subvars_for (stderr, var);
|
}
|
}
|
|
|
|
|
/* Dump variable VAR and its may-aliases to FILE. */
|
/* Dump variable VAR and its may-aliases to FILE. */
|
|
|
void
|
void
|
dump_variable (FILE *file, tree var)
|
dump_variable (FILE *file, tree var)
|
{
|
{
|
var_ann_t ann;
|
var_ann_t ann;
|
|
|
if (TREE_CODE (var) == SSA_NAME)
|
if (TREE_CODE (var) == SSA_NAME)
|
{
|
{
|
if (POINTER_TYPE_P (TREE_TYPE (var)))
|
if (POINTER_TYPE_P (TREE_TYPE (var)))
|
dump_points_to_info_for (file, var);
|
dump_points_to_info_for (file, var);
|
var = SSA_NAME_VAR (var);
|
var = SSA_NAME_VAR (var);
|
}
|
}
|
|
|
if (var == NULL_TREE)
|
if (var == NULL_TREE)
|
{
|
{
|
fprintf (file, "<nil>");
|
fprintf (file, "<nil>");
|
return;
|
return;
|
}
|
}
|
|
|
print_generic_expr (file, var, dump_flags);
|
print_generic_expr (file, var, dump_flags);
|
|
|
ann = var_ann (var);
|
ann = var_ann (var);
|
|
|
fprintf (file, ", UID %u", (unsigned) DECL_UID (var));
|
fprintf (file, ", UID %u", (unsigned) DECL_UID (var));
|
|
|
fprintf (file, ", ");
|
fprintf (file, ", ");
|
print_generic_expr (file, TREE_TYPE (var), dump_flags);
|
print_generic_expr (file, TREE_TYPE (var), dump_flags);
|
|
|
if (ann && ann->symbol_mem_tag)
|
if (ann && ann->symbol_mem_tag)
|
{
|
{
|
fprintf (file, ", symbol memory tag: ");
|
fprintf (file, ", symbol memory tag: ");
|
print_generic_expr (file, ann->symbol_mem_tag, dump_flags);
|
print_generic_expr (file, ann->symbol_mem_tag, dump_flags);
|
}
|
}
|
|
|
if (ann && ann->is_aliased)
|
if (ann && ann->is_aliased)
|
fprintf (file, ", is aliased");
|
fprintf (file, ", is aliased");
|
|
|
if (TREE_ADDRESSABLE (var))
|
if (TREE_ADDRESSABLE (var))
|
fprintf (file, ", is addressable");
|
fprintf (file, ", is addressable");
|
|
|
if (is_global_var (var))
|
if (is_global_var (var))
|
fprintf (file, ", is global");
|
fprintf (file, ", is global");
|
|
|
if (TREE_THIS_VOLATILE (var))
|
if (TREE_THIS_VOLATILE (var))
|
fprintf (file, ", is volatile");
|
fprintf (file, ", is volatile");
|
|
|
if (is_call_clobbered (var))
|
if (is_call_clobbered (var))
|
{
|
{
|
fprintf (file, ", call clobbered");
|
fprintf (file, ", call clobbered");
|
if (dump_flags & TDF_DETAILS)
|
if (dump_flags & TDF_DETAILS)
|
{
|
{
|
var_ann_t va = var_ann (var);
|
var_ann_t va = var_ann (var);
|
unsigned int escape_mask = va->escape_mask;
|
unsigned int escape_mask = va->escape_mask;
|
|
|
fprintf (file, " (");
|
fprintf (file, " (");
|
if (escape_mask & ESCAPE_STORED_IN_GLOBAL)
|
if (escape_mask & ESCAPE_STORED_IN_GLOBAL)
|
fprintf (file, ", stored in global");
|
fprintf (file, ", stored in global");
|
if (escape_mask & ESCAPE_TO_ASM)
|
if (escape_mask & ESCAPE_TO_ASM)
|
fprintf (file, ", goes through ASM");
|
fprintf (file, ", goes through ASM");
|
if (escape_mask & ESCAPE_TO_CALL)
|
if (escape_mask & ESCAPE_TO_CALL)
|
fprintf (file, ", passed to call");
|
fprintf (file, ", passed to call");
|
if (escape_mask & ESCAPE_BAD_CAST)
|
if (escape_mask & ESCAPE_BAD_CAST)
|
fprintf (file, ", bad cast");
|
fprintf (file, ", bad cast");
|
if (escape_mask & ESCAPE_TO_RETURN)
|
if (escape_mask & ESCAPE_TO_RETURN)
|
fprintf (file, ", returned from func");
|
fprintf (file, ", returned from func");
|
if (escape_mask & ESCAPE_TO_PURE_CONST)
|
if (escape_mask & ESCAPE_TO_PURE_CONST)
|
fprintf (file, ", passed to pure/const");
|
fprintf (file, ", passed to pure/const");
|
if (escape_mask & ESCAPE_IS_GLOBAL)
|
if (escape_mask & ESCAPE_IS_GLOBAL)
|
fprintf (file, ", is global var");
|
fprintf (file, ", is global var");
|
if (escape_mask & ESCAPE_IS_PARM)
|
if (escape_mask & ESCAPE_IS_PARM)
|
fprintf (file, ", is incoming pointer");
|
fprintf (file, ", is incoming pointer");
|
if (escape_mask & ESCAPE_UNKNOWN)
|
if (escape_mask & ESCAPE_UNKNOWN)
|
fprintf (file, ", unknown escape");
|
fprintf (file, ", unknown escape");
|
fprintf (file, " )");
|
fprintf (file, " )");
|
}
|
}
|
}
|
}
|
|
|
if (default_def (var))
|
if (default_def (var))
|
{
|
{
|
fprintf (file, ", default def: ");
|
fprintf (file, ", default def: ");
|
print_generic_expr (file, default_def (var), dump_flags);
|
print_generic_expr (file, default_def (var), dump_flags);
|
}
|
}
|
|
|
if (may_aliases (var))
|
if (may_aliases (var))
|
{
|
{
|
fprintf (file, ", may aliases: ");
|
fprintf (file, ", may aliases: ");
|
dump_may_aliases_for (file, var);
|
dump_may_aliases_for (file, var);
|
}
|
}
|
|
|
if (get_subvars_for_var (var))
|
if (get_subvars_for_var (var))
|
{
|
{
|
fprintf (file, ", sub-vars: ");
|
fprintf (file, ", sub-vars: ");
|
dump_subvars_for (file, var);
|
dump_subvars_for (file, var);
|
}
|
}
|
|
|
fprintf (file, "\n");
|
fprintf (file, "\n");
|
}
|
}
|
|
|
|
|
/* Dump variable VAR and its may-aliases to stderr. */
|
/* Dump variable VAR and its may-aliases to stderr. */
|
|
|
void
|
void
|
debug_variable (tree var)
|
debug_variable (tree var)
|
{
|
{
|
dump_variable (stderr, var);
|
dump_variable (stderr, var);
|
}
|
}
|
|
|
|
|
/* Dump various DFA statistics to FILE. */
|
/* Dump various DFA statistics to FILE. */
|
|
|
void
|
void
|
dump_dfa_stats (FILE *file)
|
dump_dfa_stats (FILE *file)
|
{
|
{
|
struct dfa_stats_d dfa_stats;
|
struct dfa_stats_d dfa_stats;
|
|
|
unsigned long size, total = 0;
|
unsigned long size, total = 0;
|
const char * const fmt_str = "%-30s%-13s%12s\n";
|
const char * const fmt_str = "%-30s%-13s%12s\n";
|
const char * const fmt_str_1 = "%-30s%13lu%11lu%c\n";
|
const char * const fmt_str_1 = "%-30s%13lu%11lu%c\n";
|
const char * const fmt_str_3 = "%-43s%11lu%c\n";
|
const char * const fmt_str_3 = "%-43s%11lu%c\n";
|
const char *funcname
|
const char *funcname
|
= lang_hooks.decl_printable_name (current_function_decl, 2);
|
= lang_hooks.decl_printable_name (current_function_decl, 2);
|
|
|
collect_dfa_stats (&dfa_stats);
|
collect_dfa_stats (&dfa_stats);
|
|
|
fprintf (file, "\nDFA Statistics for %s\n\n", funcname);
|
fprintf (file, "\nDFA Statistics for %s\n\n", funcname);
|
|
|
fprintf (file, "---------------------------------------------------------\n");
|
fprintf (file, "---------------------------------------------------------\n");
|
fprintf (file, fmt_str, "", " Number of ", "Memory");
|
fprintf (file, fmt_str, "", " Number of ", "Memory");
|
fprintf (file, fmt_str, "", " instances ", "used ");
|
fprintf (file, fmt_str, "", " instances ", "used ");
|
fprintf (file, "---------------------------------------------------------\n");
|
fprintf (file, "---------------------------------------------------------\n");
|
|
|
size = num_referenced_vars * sizeof (tree);
|
size = num_referenced_vars * sizeof (tree);
|
total += size;
|
total += size;
|
fprintf (file, fmt_str_1, "Referenced variables", (unsigned long)num_referenced_vars,
|
fprintf (file, fmt_str_1, "Referenced variables", (unsigned long)num_referenced_vars,
|
SCALE (size), LABEL (size));
|
SCALE (size), LABEL (size));
|
|
|
size = dfa_stats.num_stmt_anns * sizeof (struct stmt_ann_d);
|
size = dfa_stats.num_stmt_anns * sizeof (struct stmt_ann_d);
|
total += size;
|
total += size;
|
fprintf (file, fmt_str_1, "Statements annotated", dfa_stats.num_stmt_anns,
|
fprintf (file, fmt_str_1, "Statements annotated", dfa_stats.num_stmt_anns,
|
SCALE (size), LABEL (size));
|
SCALE (size), LABEL (size));
|
|
|
size = dfa_stats.num_var_anns * sizeof (struct var_ann_d);
|
size = dfa_stats.num_var_anns * sizeof (struct var_ann_d);
|
total += size;
|
total += size;
|
fprintf (file, fmt_str_1, "Variables annotated", dfa_stats.num_var_anns,
|
fprintf (file, fmt_str_1, "Variables annotated", dfa_stats.num_var_anns,
|
SCALE (size), LABEL (size));
|
SCALE (size), LABEL (size));
|
|
|
size = dfa_stats.num_uses * sizeof (tree *);
|
size = dfa_stats.num_uses * sizeof (tree *);
|
total += size;
|
total += size;
|
fprintf (file, fmt_str_1, "USE operands", dfa_stats.num_uses,
|
fprintf (file, fmt_str_1, "USE operands", dfa_stats.num_uses,
|
SCALE (size), LABEL (size));
|
SCALE (size), LABEL (size));
|
|
|
size = dfa_stats.num_defs * sizeof (tree *);
|
size = dfa_stats.num_defs * sizeof (tree *);
|
total += size;
|
total += size;
|
fprintf (file, fmt_str_1, "DEF operands", dfa_stats.num_defs,
|
fprintf (file, fmt_str_1, "DEF operands", dfa_stats.num_defs,
|
SCALE (size), LABEL (size));
|
SCALE (size), LABEL (size));
|
|
|
size = dfa_stats.num_vuses * sizeof (tree *);
|
size = dfa_stats.num_vuses * sizeof (tree *);
|
total += size;
|
total += size;
|
fprintf (file, fmt_str_1, "VUSE operands", dfa_stats.num_vuses,
|
fprintf (file, fmt_str_1, "VUSE operands", dfa_stats.num_vuses,
|
SCALE (size), LABEL (size));
|
SCALE (size), LABEL (size));
|
|
|
size = dfa_stats.num_v_may_defs * sizeof (tree *);
|
size = dfa_stats.num_v_may_defs * sizeof (tree *);
|
total += size;
|
total += size;
|
fprintf (file, fmt_str_1, "V_MAY_DEF operands", dfa_stats.num_v_may_defs,
|
fprintf (file, fmt_str_1, "V_MAY_DEF operands", dfa_stats.num_v_may_defs,
|
SCALE (size), LABEL (size));
|
SCALE (size), LABEL (size));
|
|
|
size = dfa_stats.num_v_must_defs * sizeof (tree *);
|
size = dfa_stats.num_v_must_defs * sizeof (tree *);
|
total += size;
|
total += size;
|
fprintf (file, fmt_str_1, "V_MUST_DEF operands", dfa_stats.num_v_must_defs,
|
fprintf (file, fmt_str_1, "V_MUST_DEF operands", dfa_stats.num_v_must_defs,
|
SCALE (size), LABEL (size));
|
SCALE (size), LABEL (size));
|
|
|
size = dfa_stats.num_phis * sizeof (struct tree_phi_node);
|
size = dfa_stats.num_phis * sizeof (struct tree_phi_node);
|
total += size;
|
total += size;
|
fprintf (file, fmt_str_1, "PHI nodes", dfa_stats.num_phis,
|
fprintf (file, fmt_str_1, "PHI nodes", dfa_stats.num_phis,
|
SCALE (size), LABEL (size));
|
SCALE (size), LABEL (size));
|
|
|
size = dfa_stats.num_phi_args * sizeof (struct phi_arg_d);
|
size = dfa_stats.num_phi_args * sizeof (struct phi_arg_d);
|
total += size;
|
total += size;
|
fprintf (file, fmt_str_1, "PHI arguments", dfa_stats.num_phi_args,
|
fprintf (file, fmt_str_1, "PHI arguments", dfa_stats.num_phi_args,
|
SCALE (size), LABEL (size));
|
SCALE (size), LABEL (size));
|
|
|
fprintf (file, "---------------------------------------------------------\n");
|
fprintf (file, "---------------------------------------------------------\n");
|
fprintf (file, fmt_str_3, "Total memory used by DFA/SSA data", SCALE (total),
|
fprintf (file, fmt_str_3, "Total memory used by DFA/SSA data", SCALE (total),
|
LABEL (total));
|
LABEL (total));
|
fprintf (file, "---------------------------------------------------------\n");
|
fprintf (file, "---------------------------------------------------------\n");
|
fprintf (file, "\n");
|
fprintf (file, "\n");
|
|
|
if (dfa_stats.num_phis)
|
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: %d)\n",
|
(float) dfa_stats.num_phi_args / (float) dfa_stats.num_phis,
|
(float) dfa_stats.num_phi_args / (float) dfa_stats.num_phis,
|
dfa_stats.max_num_phi_args);
|
dfa_stats.max_num_phi_args);
|
|
|
fprintf (file, "\n");
|
fprintf (file, "\n");
|
}
|
}
|
|
|
|
|
/* Dump DFA statistics on stderr. */
|
/* Dump DFA statistics on stderr. */
|
|
|
void
|
void
|
debug_dfa_stats (void)
|
debug_dfa_stats (void)
|
{
|
{
|
dump_dfa_stats (stderr);
|
dump_dfa_stats (stderr);
|
}
|
}
|
|
|
|
|
/* Collect DFA statistics and store them in the structure pointed to by
|
/* Collect DFA statistics and store them in the structure pointed to by
|
DFA_STATS_P. */
|
DFA_STATS_P. */
|
|
|
static void
|
static void
|
collect_dfa_stats (struct dfa_stats_d *dfa_stats_p)
|
collect_dfa_stats (struct dfa_stats_d *dfa_stats_p)
|
{
|
{
|
struct pointer_set_t *pset;
|
struct pointer_set_t *pset;
|
basic_block bb;
|
basic_block bb;
|
block_stmt_iterator i;
|
block_stmt_iterator i;
|
|
|
gcc_assert (dfa_stats_p);
|
gcc_assert (dfa_stats_p);
|
|
|
memset ((void *)dfa_stats_p, 0, sizeof (struct dfa_stats_d));
|
memset ((void *)dfa_stats_p, 0, sizeof (struct dfa_stats_d));
|
|
|
/* Walk all the trees in the function counting references. Start at
|
/* Walk all the trees in the function counting references. Start at
|
basic block NUM_FIXED_BLOCKS, but don't stop at block boundaries. */
|
basic block NUM_FIXED_BLOCKS, but don't stop at block boundaries. */
|
pset = pointer_set_create ();
|
pset = pointer_set_create ();
|
|
|
for (i = bsi_start (BASIC_BLOCK (NUM_FIXED_BLOCKS));
|
for (i = bsi_start (BASIC_BLOCK (NUM_FIXED_BLOCKS));
|
!bsi_end_p (i); bsi_next (&i))
|
!bsi_end_p (i); bsi_next (&i))
|
walk_tree (bsi_stmt_ptr (i), collect_dfa_stats_r, (void *) dfa_stats_p,
|
walk_tree (bsi_stmt_ptr (i), collect_dfa_stats_r, (void *) dfa_stats_p,
|
pset);
|
pset);
|
|
|
pointer_set_destroy (pset);
|
pointer_set_destroy (pset);
|
|
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
{
|
{
|
tree phi;
|
tree phi;
|
for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
|
for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
|
{
|
{
|
dfa_stats_p->num_phis++;
|
dfa_stats_p->num_phis++;
|
dfa_stats_p->num_phi_args += PHI_NUM_ARGS (phi);
|
dfa_stats_p->num_phi_args += PHI_NUM_ARGS (phi);
|
if (PHI_NUM_ARGS (phi) > dfa_stats_p->max_num_phi_args)
|
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->max_num_phi_args = PHI_NUM_ARGS (phi);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Callback for walk_tree to collect DFA statistics for a tree and its
|
/* Callback for walk_tree to collect DFA statistics for a tree and its
|
children. */
|
children. */
|
|
|
static tree
|
static tree
|
collect_dfa_stats_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
|
collect_dfa_stats_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
|
void *data)
|
void *data)
|
{
|
{
|
tree t = *tp;
|
tree t = *tp;
|
struct dfa_stats_d *dfa_stats_p = (struct dfa_stats_d *)data;
|
struct dfa_stats_d *dfa_stats_p = (struct dfa_stats_d *)data;
|
|
|
if (t->common.ann)
|
if (t->common.ann)
|
{
|
{
|
switch (ann_type (t->common.ann))
|
switch (ann_type (t->common.ann))
|
{
|
{
|
case STMT_ANN:
|
case STMT_ANN:
|
{
|
{
|
dfa_stats_p->num_stmt_anns++;
|
dfa_stats_p->num_stmt_anns++;
|
dfa_stats_p->num_defs += NUM_SSA_OPERANDS (t, SSA_OP_DEF);
|
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_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_v_may_defs += NUM_SSA_OPERANDS (t, SSA_OP_VMAYDEF);
|
dfa_stats_p->num_vuses += NUM_SSA_OPERANDS (t, SSA_OP_VUSE);
|
dfa_stats_p->num_vuses += NUM_SSA_OPERANDS (t, SSA_OP_VUSE);
|
dfa_stats_p->num_v_must_defs +=
|
dfa_stats_p->num_v_must_defs +=
|
NUM_SSA_OPERANDS (t, SSA_OP_VMUSTDEF);
|
NUM_SSA_OPERANDS (t, SSA_OP_VMUSTDEF);
|
break;
|
break;
|
}
|
}
|
|
|
case VAR_ANN:
|
case VAR_ANN:
|
dfa_stats_p->num_var_anns++;
|
dfa_stats_p->num_var_anns++;
|
break;
|
break;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
|
|
/*---------------------------------------------------------------------------
|
/*---------------------------------------------------------------------------
|
Miscellaneous helpers
|
Miscellaneous helpers
|
---------------------------------------------------------------------------*/
|
---------------------------------------------------------------------------*/
|
/* Callback for walk_tree. Used to collect variables referenced in
|
/* Callback for walk_tree. Used to collect variables referenced in
|
the function. */
|
the function. */
|
|
|
static tree
|
static tree
|
find_vars_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
|
find_vars_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
|
{
|
{
|
/* If T is a regular variable that the optimizers are interested
|
/* If T is a regular variable that the optimizers are interested
|
in, add it to the list of variables. */
|
in, add it to the list of variables. */
|
if (SSA_VAR_P (*tp))
|
if (SSA_VAR_P (*tp))
|
add_referenced_var (*tp);
|
add_referenced_var (*tp);
|
|
|
/* Type, _DECL and constant nodes have no interesting children.
|
/* Type, _DECL and constant nodes have no interesting children.
|
Ignore them. */
|
Ignore them. */
|
else if (IS_TYPE_OR_DECL_P (*tp) || CONSTANT_CLASS_P (*tp))
|
else if (IS_TYPE_OR_DECL_P (*tp) || CONSTANT_CLASS_P (*tp))
|
*walk_subtrees = 0;
|
*walk_subtrees = 0;
|
|
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
/* Lookup UID in the referenced_vars hashtable and return the associated
|
/* Lookup UID in the referenced_vars hashtable and return the associated
|
variable. */
|
variable. */
|
|
|
tree
|
tree
|
referenced_var_lookup (unsigned int uid)
|
referenced_var_lookup (unsigned int uid)
|
{
|
{
|
struct int_tree_map *h, in;
|
struct int_tree_map *h, in;
|
in.uid = uid;
|
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 (referenced_vars, &in, uid);
|
gcc_assert (h || uid == 0);
|
gcc_assert (h || uid == 0);
|
if (h)
|
if (h)
|
return h->to;
|
return h->to;
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
/* 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. */
|
Return true if it required insertion. */
|
|
|
bool
|
bool
|
referenced_var_check_and_insert (tree to)
|
referenced_var_check_and_insert (tree to)
|
{
|
{
|
struct int_tree_map *h, in;
|
struct int_tree_map *h, in;
|
void **loc;
|
void **loc;
|
unsigned int uid = DECL_UID (to);
|
unsigned int uid = DECL_UID (to);
|
|
|
in.uid = uid;
|
in.uid = uid;
|
in.to = to;
|
in.to = to;
|
h = (struct int_tree_map *) htab_find_with_hash (referenced_vars, &in, uid);
|
h = (struct int_tree_map *) htab_find_with_hash (referenced_vars, &in, uid);
|
|
|
if (h)
|
if (h)
|
{
|
{
|
/* DECL_UID has already been entered in the table. Verify that it is
|
/* DECL_UID has already been entered in the table. Verify that it is
|
the same entry as TO. See PR 27793. */
|
the same entry as TO. See PR 27793. */
|
gcc_assert (h->to == to);
|
gcc_assert (h->to == to);
|
return false;
|
return false;
|
}
|
}
|
|
|
h = GGC_NEW (struct int_tree_map);
|
h = GGC_NEW (struct int_tree_map);
|
h->uid = uid;
|
h->uid = uid;
|
h->to = to;
|
h->to = to;
|
loc = htab_find_slot_with_hash (referenced_vars, h, uid, INSERT);
|
loc = htab_find_slot_with_hash (referenced_vars, h, uid, INSERT);
|
*(struct int_tree_map **) loc = h;
|
*(struct int_tree_map **) loc = h;
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Lookup VAR UID in the default_defs hashtable and return the associated
|
/* Lookup VAR UID in the default_defs hashtable and return the associated
|
variable. */
|
variable. */
|
|
|
tree
|
tree
|
default_def (tree var)
|
default_def (tree var)
|
{
|
{
|
struct int_tree_map *h, in;
|
struct int_tree_map *h, in;
|
gcc_assert (SSA_VAR_P (var));
|
gcc_assert (SSA_VAR_P (var));
|
in.uid = DECL_UID (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, &in,
|
DECL_UID (var));
|
DECL_UID (var));
|
if (h)
|
if (h)
|
return h->to;
|
return h->to;
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
/* Insert the pair VAR's UID, DEF into the default_defs hashtable. */
|
/* Insert the pair VAR's UID, DEF into the default_defs hashtable. */
|
|
|
void
|
void
|
set_default_def (tree var, tree def)
|
set_default_def (tree var, tree def)
|
{
|
{
|
struct int_tree_map in;
|
struct int_tree_map in;
|
struct int_tree_map *h;
|
struct int_tree_map *h;
|
void **loc;
|
void **loc;
|
|
|
gcc_assert (SSA_VAR_P (var));
|
gcc_assert (SSA_VAR_P (var));
|
in.uid = DECL_UID (var);
|
in.uid = DECL_UID (var);
|
if (!def && default_def (var))
|
if (!def && default_def (var))
|
{
|
{
|
loc = htab_find_slot_with_hash (default_defs, &in, DECL_UID (var), INSERT);
|
loc = htab_find_slot_with_hash (default_defs, &in, DECL_UID (var), INSERT);
|
htab_remove_elt (default_defs, *loc);
|
htab_remove_elt (default_defs, *loc);
|
return;
|
return;
|
}
|
}
|
gcc_assert (TREE_CODE (def) == SSA_NAME);
|
gcc_assert (TREE_CODE (def) == SSA_NAME);
|
loc = htab_find_slot_with_hash (default_defs, &in, DECL_UID (var), INSERT);
|
loc = htab_find_slot_with_hash (default_defs, &in, DECL_UID (var), INSERT);
|
/* Default definition might be changed by tail call optimization. */
|
/* Default definition might be changed by tail call optimization. */
|
if (!*loc)
|
if (!*loc)
|
{
|
{
|
h = GGC_NEW (struct int_tree_map);
|
h = GGC_NEW (struct int_tree_map);
|
h->uid = DECL_UID (var);
|
h->uid = DECL_UID (var);
|
h->to = def;
|
h->to = def;
|
*(struct int_tree_map **) loc = h;
|
*(struct int_tree_map **) loc = h;
|
}
|
}
|
else
|
else
|
{
|
{
|
h = (struct int_tree_map *) *loc;
|
h = (struct int_tree_map *) *loc;
|
h->to = def;
|
h->to = def;
|
}
|
}
|
}
|
}
|
|
|
/* Add VAR to the list of referenced variables if it isn't already there. */
|
/* Add VAR to the list of referenced variables if it isn't already there. */
|
|
|
void
|
void
|
add_referenced_var (tree var)
|
add_referenced_var (tree var)
|
{
|
{
|
var_ann_t v_ann;
|
var_ann_t v_ann;
|
|
|
v_ann = get_var_ann (var);
|
v_ann = get_var_ann (var);
|
gcc_assert (DECL_P (var));
|
gcc_assert (DECL_P (var));
|
|
|
/* Insert VAR into the referenced_vars has table if it isn't present. */
|
/* Insert VAR into the referenced_vars has table if it isn't present. */
|
if (referenced_var_check_and_insert (var))
|
if (referenced_var_check_and_insert (var))
|
{
|
{
|
/* This is the first time we found this variable, annotate it with
|
/* This is the first time we found this variable, annotate it with
|
attributes that are intrinsic to the variable. */
|
attributes that are intrinsic to the variable. */
|
|
|
/* Tag's don't have DECL_INITIAL. */
|
/* Tag's don't have DECL_INITIAL. */
|
if (MTAG_P (var))
|
if (MTAG_P (var))
|
return;
|
return;
|
|
|
/* Scan DECL_INITIAL for pointer variables as they may contain
|
/* Scan DECL_INITIAL for pointer variables as they may contain
|
address arithmetic referencing the address of other
|
address arithmetic referencing the address of other
|
variables. */
|
variables. */
|
if (DECL_INITIAL (var)
|
if (DECL_INITIAL (var)
|
/* Initializers of external variables are not useful to the
|
/* Initializers of external variables are not useful to the
|
optimizers. */
|
optimizers. */
|
&& !DECL_EXTERNAL (var)
|
&& !DECL_EXTERNAL (var)
|
/* It's not necessary to walk the initial value of non-constant
|
/* It's not necessary to walk the initial value of non-constant
|
variables because it cannot be propagated by the
|
variables because it cannot be propagated by the
|
optimizers. */
|
optimizers. */
|
&& (TREE_CONSTANT (var) || TREE_READONLY (var)))
|
&& (TREE_CONSTANT (var) || TREE_READONLY (var)))
|
walk_tree (&DECL_INITIAL (var), find_vars_r, NULL, 0);
|
walk_tree (&DECL_INITIAL (var), find_vars_r, NULL, 0);
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Return the virtual variable associated to the non-scalar variable VAR. */
|
/* Return the virtual variable associated to the non-scalar variable VAR. */
|
|
|
tree
|
tree
|
get_virtual_var (tree var)
|
get_virtual_var (tree var)
|
{
|
{
|
STRIP_NOPS (var);
|
STRIP_NOPS (var);
|
|
|
if (TREE_CODE (var) == SSA_NAME)
|
if (TREE_CODE (var) == SSA_NAME)
|
var = SSA_NAME_VAR (var);
|
var = SSA_NAME_VAR (var);
|
|
|
while (TREE_CODE (var) == REALPART_EXPR || TREE_CODE (var) == IMAGPART_EXPR
|
while (TREE_CODE (var) == REALPART_EXPR || TREE_CODE (var) == IMAGPART_EXPR
|
|| handled_component_p (var))
|
|| handled_component_p (var))
|
var = TREE_OPERAND (var, 0);
|
var = TREE_OPERAND (var, 0);
|
|
|
/* Treating GIMPLE registers as virtual variables makes no sense.
|
/* Treating GIMPLE registers as virtual variables makes no sense.
|
Also complain if we couldn't extract a _DECL out of the original
|
Also complain if we couldn't extract a _DECL out of the original
|
expression. */
|
expression. */
|
gcc_assert (SSA_VAR_P (var));
|
gcc_assert (SSA_VAR_P (var));
|
gcc_assert (!is_gimple_reg (var));
|
gcc_assert (!is_gimple_reg (var));
|
|
|
return var;
|
return var;
|
}
|
}
|
|
|
/* Mark all the non-SSA variables found in STMT's operands to be
|
/* Mark all the non-SSA variables found in STMT's operands to be
|
processed by update_ssa. */
|
processed by update_ssa. */
|
|
|
void
|
void
|
mark_new_vars_to_rename (tree stmt)
|
mark_new_vars_to_rename (tree stmt)
|
{
|
{
|
ssa_op_iter iter;
|
ssa_op_iter iter;
|
tree val;
|
tree val;
|
bitmap vars_in_vops_to_rename;
|
bitmap vars_in_vops_to_rename;
|
bool found_exposed_symbol = false;
|
bool found_exposed_symbol = false;
|
int v_may_defs_before, v_may_defs_after;
|
int v_may_defs_before, v_may_defs_after;
|
int v_must_defs_before, v_must_defs_after;
|
int v_must_defs_before, v_must_defs_after;
|
|
|
if (TREE_CODE (stmt) == PHI_NODE)
|
if (TREE_CODE (stmt) == PHI_NODE)
|
return;
|
return;
|
|
|
get_stmt_ann (stmt);
|
get_stmt_ann (stmt);
|
vars_in_vops_to_rename = BITMAP_ALLOC (NULL);
|
vars_in_vops_to_rename = BITMAP_ALLOC (NULL);
|
|
|
/* Before re-scanning the statement for operands, mark the existing
|
/* Before re-scanning the statement for operands, mark the existing
|
virtual operands to be renamed again. We do this because when new
|
virtual operands to be renamed again. We do this because when new
|
symbols are exposed, the virtual operands that were here before due to
|
symbols are exposed, the virtual operands that were here before due to
|
aliasing will probably be removed by the call to get_stmt_operand.
|
aliasing will probably be removed by the call to get_stmt_operand.
|
Therefore, we need to flag them to be renamed beforehand.
|
Therefore, we need to flag them to be renamed beforehand.
|
|
|
We flag them in a separate bitmap because we don't really want to
|
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
|
rename them if there are not any newly exposed symbols in the
|
statement operands. */
|
statement operands. */
|
v_may_defs_before = NUM_SSA_OPERANDS (stmt, SSA_OP_VMAYDEF);
|
v_may_defs_before = NUM_SSA_OPERANDS (stmt, SSA_OP_VMAYDEF);
|
v_must_defs_before = NUM_SSA_OPERANDS (stmt, SSA_OP_VMUSTDEF);
|
v_must_defs_before = NUM_SSA_OPERANDS (stmt, SSA_OP_VMUSTDEF);
|
|
|
FOR_EACH_SSA_TREE_OPERAND (val, stmt, iter,
|
FOR_EACH_SSA_TREE_OPERAND (val, stmt, iter,
|
SSA_OP_VMAYDEF | SSA_OP_VUSE | SSA_OP_VMUSTDEF)
|
SSA_OP_VMAYDEF | SSA_OP_VUSE | SSA_OP_VMUSTDEF)
|
{
|
{
|
if (!DECL_P (val))
|
if (!DECL_P (val))
|
val = SSA_NAME_VAR (val);
|
val = SSA_NAME_VAR (val);
|
bitmap_set_bit (vars_in_vops_to_rename, DECL_UID (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
|
/* Now force an operand re-scan on the statement and mark any newly
|
exposed variables. */
|
exposed variables. */
|
update_stmt (stmt);
|
update_stmt (stmt);
|
|
|
v_may_defs_after = NUM_SSA_OPERANDS (stmt, SSA_OP_VMAYDEF);
|
v_may_defs_after = NUM_SSA_OPERANDS (stmt, SSA_OP_VMAYDEF);
|
v_must_defs_after = NUM_SSA_OPERANDS (stmt, SSA_OP_VMUSTDEF);
|
v_must_defs_after = NUM_SSA_OPERANDS (stmt, SSA_OP_VMUSTDEF);
|
|
|
FOR_EACH_SSA_TREE_OPERAND (val, stmt, iter, SSA_OP_ALL_OPERANDS)
|
FOR_EACH_SSA_TREE_OPERAND (val, stmt, iter, SSA_OP_ALL_OPERANDS)
|
if (DECL_P (val))
|
if (DECL_P (val))
|
{
|
{
|
found_exposed_symbol = true;
|
found_exposed_symbol = true;
|
mark_sym_for_renaming (val);
|
mark_sym_for_renaming (val);
|
}
|
}
|
|
|
/* If we found any newly exposed symbols, or if there are fewer VDEF
|
/* If we found any newly exposed symbols, or if there are fewer VDEF
|
operands in the statement, add the variables we had set in
|
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
|
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
|
vanishing VDEFs because in those cases, the names that were formerly
|
generated by this statement are not going to be available anymore. */
|
generated by this statement are not going to be available anymore. */
|
if (found_exposed_symbol
|
if (found_exposed_symbol
|
|| v_may_defs_before > v_may_defs_after
|
|| v_may_defs_before > v_may_defs_after
|
|| v_must_defs_before > v_must_defs_after)
|
|| v_must_defs_before > v_must_defs_after)
|
mark_set_for_renaming (vars_in_vops_to_rename);
|
mark_set_for_renaming (vars_in_vops_to_rename);
|
|
|
BITMAP_FREE (vars_in_vops_to_rename);
|
BITMAP_FREE (vars_in_vops_to_rename);
|
}
|
}
|
|
|
/* Find all variables within the gimplified statement that were not previously
|
/* Find all variables within the gimplified statement that were not previously
|
visible to the function and add them to the referenced variables list. */
|
visible to the function and add them to the referenced variables list. */
|
|
|
static tree
|
static tree
|
find_new_referenced_vars_1 (tree *tp, int *walk_subtrees,
|
find_new_referenced_vars_1 (tree *tp, int *walk_subtrees,
|
void *data ATTRIBUTE_UNUSED)
|
void *data ATTRIBUTE_UNUSED)
|
{
|
{
|
tree t = *tp;
|
tree t = *tp;
|
|
|
if (TREE_CODE (t) == VAR_DECL && !var_ann (t))
|
if (TREE_CODE (t) == VAR_DECL && !var_ann (t))
|
{
|
{
|
add_referenced_var (t);
|
add_referenced_var (t);
|
mark_sym_for_renaming (t);
|
mark_sym_for_renaming (t);
|
}
|
}
|
|
|
if (IS_TYPE_OR_DECL_P (t))
|
if (IS_TYPE_OR_DECL_P (t))
|
*walk_subtrees = 0;
|
*walk_subtrees = 0;
|
|
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
void
|
void
|
find_new_referenced_vars (tree *stmt_p)
|
find_new_referenced_vars (tree *stmt_p)
|
{
|
{
|
walk_tree (stmt_p, find_new_referenced_vars_1, NULL, NULL);
|
walk_tree (stmt_p, find_new_referenced_vars_1, NULL, NULL);
|
}
|
}
|
|
|
|
|
/* If REF is a handled component reference for a structure, return the
|
/* If REF is a handled component reference for a structure, return the
|
base variable. The access range is delimited by bit positions *POFFSET and
|
base variable. The access range is delimited by bit positions *POFFSET and
|
*POFFSET + *PMAX_SIZE. The access size is *PSIZE bits. If either
|
*POFFSET + *PMAX_SIZE. The access size is *PSIZE bits. If either
|
*PSIZE or *PMAX_SIZE is -1, they could not be determined. If *PSIZE
|
*PSIZE or *PMAX_SIZE is -1, they could not be determined. If *PSIZE
|
and *PMAX_SIZE are equal, the access is non-variable. */
|
and *PMAX_SIZE are equal, the access is non-variable. */
|
|
|
tree
|
tree
|
get_ref_base_and_extent (tree exp, HOST_WIDE_INT *poffset,
|
get_ref_base_and_extent (tree exp, HOST_WIDE_INT *poffset,
|
HOST_WIDE_INT *psize,
|
HOST_WIDE_INT *psize,
|
HOST_WIDE_INT *pmax_size)
|
HOST_WIDE_INT *pmax_size)
|
{
|
{
|
HOST_WIDE_INT bitsize = -1;
|
HOST_WIDE_INT bitsize = -1;
|
HOST_WIDE_INT maxsize = -1;
|
HOST_WIDE_INT maxsize = -1;
|
tree size_tree = NULL_TREE;
|
tree size_tree = NULL_TREE;
|
tree bit_offset = bitsize_zero_node;
|
tree bit_offset = bitsize_zero_node;
|
bool seen_variable_array_ref = false;
|
bool seen_variable_array_ref = false;
|
|
|
gcc_assert (!SSA_VAR_P (exp));
|
gcc_assert (!SSA_VAR_P (exp));
|
|
|
/* First get the final access size from just the outermost expression. */
|
/* First get the final access size from just the outermost expression. */
|
if (TREE_CODE (exp) == COMPONENT_REF)
|
if (TREE_CODE (exp) == COMPONENT_REF)
|
size_tree = DECL_SIZE (TREE_OPERAND (exp, 1));
|
size_tree = DECL_SIZE (TREE_OPERAND (exp, 1));
|
else if (TREE_CODE (exp) == BIT_FIELD_REF)
|
else if (TREE_CODE (exp) == BIT_FIELD_REF)
|
size_tree = TREE_OPERAND (exp, 1);
|
size_tree = TREE_OPERAND (exp, 1);
|
else
|
else
|
{
|
{
|
enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
|
enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
|
if (mode == BLKmode)
|
if (mode == BLKmode)
|
size_tree = TYPE_SIZE (TREE_TYPE (exp));
|
size_tree = TYPE_SIZE (TREE_TYPE (exp));
|
else
|
else
|
bitsize = GET_MODE_BITSIZE (mode);
|
bitsize = GET_MODE_BITSIZE (mode);
|
}
|
}
|
if (size_tree != NULL_TREE)
|
if (size_tree != NULL_TREE)
|
{
|
{
|
if (! host_integerp (size_tree, 1))
|
if (! host_integerp (size_tree, 1))
|
bitsize = -1;
|
bitsize = -1;
|
else
|
else
|
bitsize = TREE_INT_CST_LOW (size_tree);
|
bitsize = TREE_INT_CST_LOW (size_tree);
|
}
|
}
|
|
|
/* Initially, maxsize is the same as the accessed element size.
|
/* Initially, maxsize is the same as the accessed element size.
|
In the following it will only grow (or become -1). */
|
In the following it will only grow (or become -1). */
|
maxsize = bitsize;
|
maxsize = bitsize;
|
|
|
/* Compute cumulative bit-offset for nested component-refs and array-refs,
|
/* Compute cumulative bit-offset for nested component-refs and array-refs,
|
and find the ultimate containing object. */
|
and find the ultimate containing object. */
|
while (1)
|
while (1)
|
{
|
{
|
switch (TREE_CODE (exp))
|
switch (TREE_CODE (exp))
|
{
|
{
|
case BIT_FIELD_REF:
|
case BIT_FIELD_REF:
|
bit_offset = size_binop (PLUS_EXPR, bit_offset,
|
bit_offset = size_binop (PLUS_EXPR, bit_offset,
|
TREE_OPERAND (exp, 2));
|
TREE_OPERAND (exp, 2));
|
break;
|
break;
|
|
|
case COMPONENT_REF:
|
case COMPONENT_REF:
|
{
|
{
|
tree field = TREE_OPERAND (exp, 1);
|
tree field = TREE_OPERAND (exp, 1);
|
tree this_offset = component_ref_field_offset (exp);
|
tree this_offset = component_ref_field_offset (exp);
|
|
|
if (this_offset && TREE_CODE (this_offset) == INTEGER_CST)
|
if (this_offset && TREE_CODE (this_offset) == INTEGER_CST)
|
{
|
{
|
this_offset = size_binop (MULT_EXPR,
|
this_offset = size_binop (MULT_EXPR,
|
fold_convert (bitsizetype,
|
fold_convert (bitsizetype,
|
this_offset),
|
this_offset),
|
bitsize_unit_node);
|
bitsize_unit_node);
|
bit_offset = size_binop (PLUS_EXPR,
|
bit_offset = size_binop (PLUS_EXPR,
|
bit_offset, this_offset);
|
bit_offset, this_offset);
|
bit_offset = size_binop (PLUS_EXPR, bit_offset,
|
bit_offset = size_binop (PLUS_EXPR, bit_offset,
|
DECL_FIELD_BIT_OFFSET (field));
|
DECL_FIELD_BIT_OFFSET (field));
|
}
|
}
|
else
|
else
|
{
|
{
|
tree csize = TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp, 0)));
|
tree csize = TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp, 0)));
|
/* We need to adjust maxsize to the whole structure bitsize.
|
/* 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 sofar,
|
because that would get us out of the structure otherwise. */
|
because that would get us out of the structure otherwise. */
|
if (maxsize != -1
|
if (maxsize != -1
|
&& csize && host_integerp (csize, 1))
|
&& csize && host_integerp (csize, 1))
|
{
|
{
|
maxsize = (TREE_INT_CST_LOW (csize)
|
maxsize = (TREE_INT_CST_LOW (csize)
|
- TREE_INT_CST_LOW (bit_offset));
|
- TREE_INT_CST_LOW (bit_offset));
|
}
|
}
|
else
|
else
|
maxsize = -1;
|
maxsize = -1;
|
}
|
}
|
}
|
}
|
break;
|
break;
|
|
|
case ARRAY_REF:
|
case ARRAY_REF:
|
case ARRAY_RANGE_REF:
|
case ARRAY_RANGE_REF:
|
{
|
{
|
tree index = TREE_OPERAND (exp, 1);
|
tree index = TREE_OPERAND (exp, 1);
|
tree low_bound = array_ref_low_bound (exp);
|
tree low_bound = array_ref_low_bound (exp);
|
tree unit_size = array_ref_element_size (exp);
|
tree unit_size = array_ref_element_size (exp);
|
|
|
if (! integer_zerop (low_bound))
|
if (! integer_zerop (low_bound))
|
index = fold_build2 (MINUS_EXPR, TREE_TYPE (index),
|
index = fold_build2 (MINUS_EXPR, TREE_TYPE (index),
|
index, low_bound);
|
index, low_bound);
|
index = size_binop (MULT_EXPR,
|
index = size_binop (MULT_EXPR,
|
fold_convert (sizetype, index), unit_size);
|
fold_convert (sizetype, index), unit_size);
|
if (TREE_CODE (index) == INTEGER_CST)
|
if (TREE_CODE (index) == INTEGER_CST)
|
{
|
{
|
index = size_binop (MULT_EXPR,
|
index = size_binop (MULT_EXPR,
|
fold_convert (bitsizetype, index),
|
fold_convert (bitsizetype, index),
|
bitsize_unit_node);
|
bitsize_unit_node);
|
bit_offset = size_binop (PLUS_EXPR, bit_offset, index);
|
bit_offset = size_binop (PLUS_EXPR, bit_offset, index);
|
|
|
/* An array ref with a constant index up in the structure
|
/* An array ref with a constant index up in the structure
|
hierarchy will constrain the size of any variable array ref
|
hierarchy will constrain the size of any variable array ref
|
lower in the access hierarchy. */
|
lower in the access hierarchy. */
|
seen_variable_array_ref = false;
|
seen_variable_array_ref = false;
|
}
|
}
|
else
|
else
|
{
|
{
|
tree asize = TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp, 0)));
|
tree asize = TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp, 0)));
|
/* We need to adjust maxsize to the whole array bitsize.
|
/* 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 sofar,
|
because that would get us outside of the array otherwise. */
|
because that would get us outside of the array otherwise. */
|
if (maxsize != -1
|
if (maxsize != -1
|
&& asize && host_integerp (asize, 1))
|
&& asize && host_integerp (asize, 1))
|
{
|
{
|
maxsize = (TREE_INT_CST_LOW (asize)
|
maxsize = (TREE_INT_CST_LOW (asize)
|
- TREE_INT_CST_LOW (bit_offset));
|
- TREE_INT_CST_LOW (bit_offset));
|
}
|
}
|
else
|
else
|
maxsize = -1;
|
maxsize = -1;
|
|
|
/* Remember that we have seen an array ref with a variable
|
/* Remember that we have seen an array ref with a variable
|
index. */
|
index. */
|
seen_variable_array_ref = true;
|
seen_variable_array_ref = true;
|
}
|
}
|
}
|
}
|
break;
|
break;
|
|
|
case REALPART_EXPR:
|
case REALPART_EXPR:
|
break;
|
break;
|
|
|
case IMAGPART_EXPR:
|
case IMAGPART_EXPR:
|
bit_offset = size_binop (PLUS_EXPR, bit_offset,
|
bit_offset = size_binop (PLUS_EXPR, bit_offset,
|
bitsize_int (bitsize));
|
bitsize_int (bitsize));
|
break;
|
break;
|
|
|
case VIEW_CONVERT_EXPR:
|
case VIEW_CONVERT_EXPR:
|
/* ??? We probably should give up here and bail out. */
|
/* ??? We probably should give up here and bail out. */
|
break;
|
break;
|
|
|
default:
|
default:
|
goto done;
|
goto done;
|
}
|
}
|
|
|
exp = TREE_OPERAND (exp, 0);
|
exp = TREE_OPERAND (exp, 0);
|
}
|
}
|
done:
|
done:
|
|
|
/* We need to deal with variable arrays ending structures such as
|
/* We need to deal with variable arrays ending structures such as
|
struct { int length; int a[1]; } x; x.a[d]
|
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; 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 { struct { int a[1]; } a[1]; } x; x.a[0][d], x.a[d][0]
|
where we do not know maxsize for variable index accesses to
|
where we do not know maxsize for variable index accesses to
|
the array. The simplest way to conservatively deal with this
|
the array. The simplest way to conservatively deal with this
|
is to punt in the case that offset + maxsize reaches the
|
is to punt in the case that offset + maxsize reaches the
|
base type boundary. */
|
base type boundary. */
|
if (seen_variable_array_ref
|
if (seen_variable_array_ref
|
&& maxsize != -1
|
&& maxsize != -1
|
&& host_integerp (TYPE_SIZE (TREE_TYPE (exp)), 1)
|
&& host_integerp (TYPE_SIZE (TREE_TYPE (exp)), 1)
|
&& TREE_INT_CST_LOW (bit_offset) + maxsize
|
&& TREE_INT_CST_LOW (bit_offset) + maxsize
|
== TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (exp))))
|
== TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (exp))))
|
maxsize = -1;
|
maxsize = -1;
|
|
|
/* ??? Due to negative offsets in ARRAY_REF we can end up with
|
/* ??? Due to negative offsets in ARRAY_REF we can end up with
|
negative bit_offset here. We might want to store a zero offset
|
negative bit_offset here. We might want to store a zero offset
|
in this case. */
|
in this case. */
|
*poffset = TREE_INT_CST_LOW (bit_offset);
|
*poffset = TREE_INT_CST_LOW (bit_offset);
|
*psize = bitsize;
|
*psize = bitsize;
|
*pmax_size = maxsize;
|
*pmax_size = maxsize;
|
|
|
return exp;
|
return exp;
|
}
|
}
|
|
|
