OpenE2K/gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
f43c39352e
gcc/gcc/tree-dfa.c
Alexandre Oliva 12c30f2fba re PR bootstrap/47402 (Bootstrap comparison failure) 
PR debug/47402
Temporarily revert:
2011-01-21  Alexandre Oliva  <aoliva@redhat.com>
PR debug/47106
* tree-dfa.c (create_var_ann): Mark variable as used.

From-SVN: r169107
2011-01-21 22:11:24 +00:00

1090 lines
29 KiB
C
Raw Blame History

/* Data flow functions for trees.
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.
GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "hashtab.h"
#include "pointer-set.h"
#include "tree.h"
#include "tm_p.h"
#include "basic-block.h"
#include "output.h"
#include "timevar.h"
#include "ggc.h"
#include "langhooks.h"
#include "flags.h"
#include "function.h"
#include "tree-pretty-print.h"
#include "tree-dump.h"
#include "gimple.h"
#include "tree-flow.h"
#include "tree-inline.h"
#include "tree-pass.h"
#include "convert.h"
#include "params.h"
#include "cgraph.h"
/* Build and maintain data flow information for trees. */
/* Counters used to display DFA and SSA statistics. */
struct dfa_stats_d
{
long num_var_anns;
long num_defs;
long num_uses;
long num_phis;
long 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 find_vars_r (tree *, int *, void *);
/*---------------------------------------------------------------------------
Dataflow analysis (DFA) routines
---------------------------------------------------------------------------*/
/* Find all the variables referenced in the function. This function
builds the global arrays REFERENCED_VARS and CALL_CLOBBERED_VARS.
Note that this function does not look for statement operands, it simply
determines what variables are referenced in the program and detects
various attributes for each variable used by alias analysis and the
optimizer. */
static unsigned int
find_referenced_vars (void)
{
basic_block bb;
gimple_stmt_iterator si;
FOR_EACH_BB (bb)
{
for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
{
gimple stmt = gsi_stmt (si);
if (is_gimple_debug (stmt))
continue;
find_referenced_vars_in (gsi_stmt (si));
}
for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
find_referenced_vars_in (gsi_stmt (si));
}
return 0;
}
struct gimple_opt_pass pass_referenced_vars =
{
{
GIMPLE_PASS,
"*referenced_vars", /* name */
NULL, /* gate */
find_referenced_vars, /* execute */
NULL, /* sub */
NULL, /* next */
0, /* static_pass_number */
TV_FIND_REFERENCED_VARS, /* tv_id */
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 */
}
};
/*---------------------------------------------------------------------------
Manage annotations
---------------------------------------------------------------------------*/
/* Create a new annotation for a _DECL node T. */
var_ann_t
create_var_ann (tree t)
{
var_ann_t ann;
gcc_assert (t);
gcc_assert (TREE_CODE (t) == VAR_DECL
|| TREE_CODE (t) == PARM_DECL
|| TREE_CODE (t) == RESULT_DECL);
ann = ggc_alloc_cleared_var_ann_d ();
*DECL_VAR_ANN_PTR (t) = ann;
return ann;
}
/* Renumber all of the gimple stmt uids. */
void
renumber_gimple_stmt_uids (void)
{
basic_block bb;
set_gimple_stmt_max_uid (cfun, 0);
FOR_ALL_BB (bb)
{
gimple_stmt_iterator bsi;
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));
}
}
}
/* Like renumber_gimple_stmt_uids, but only do work on the basic blocks
in BLOCKS, of which there are N_BLOCKS. Also renumbers PHIs. */
void
renumber_gimple_stmt_uids_in_blocks (basic_block *blocks, int n_blocks)
{
int i;
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_reg (type, prefix);
if (gimple_referenced_vars (cfun))
{
add_referenced_var (t);
mark_sym_for_renaming (t);
}
return t;
}
/*---------------------------------------------------------------------------
Debugging functions
---------------------------------------------------------------------------*/
/* Dump the list of all the referenced variables in the current function to
FILE. */
void
dump_referenced_vars (FILE *file)
{
tree var;
referenced_var_iterator rvi;
fprintf (file, "\nReferenced variables in %s: %u\n\n",
get_name (current_function_decl), (unsigned) num_referenced_vars);
FOR_EACH_REFERENCED_VAR (var, rvi)
{
fprintf (file, "Variable: ");
dump_variable (file, var);
}
fprintf (file, "\n");
}
/* Dump the list of all the referenced variables to stderr. */
DEBUG_FUNCTION void
debug_referenced_vars (void)
{
dump_referenced_vars (stderr);
}
/* Dump variable VAR and its may-aliases to FILE. */
void
dump_variable (FILE *file, tree var)
{
if (TREE_CODE (var) == SSA_NAME)
{
if (POINTER_TYPE_P (TREE_TYPE (var)))
dump_points_to_info_for (file, var);
var = SSA_NAME_VAR (var);
}
if (var == NULL_TREE)
{
fprintf (file, "<nil>");
return;
}
print_generic_expr (file, var, dump_flags);
fprintf (file, ", UID D.%u", (unsigned) DECL_UID (var));
if (DECL_PT_UID (var) != DECL_UID (var))
fprintf (file, ", PT-UID D.%u", (unsigned) DECL_PT_UID (var));
fprintf (file, ", ");
print_generic_expr (file, TREE_TYPE (var), dump_flags);
if (TREE_ADDRESSABLE (var))
fprintf (file, ", is addressable");
if (is_global_var (var))
fprintf (file, ", is global");
if (TREE_THIS_VOLATILE (var))
fprintf (file, ", is volatile");
if (cfun && gimple_default_def (cfun, var))
{
fprintf (file, ", default def: ");
print_generic_expr (file, gimple_default_def (cfun, var), dump_flags);
}
if (DECL_INITIAL (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. */
DEBUG_FUNCTION void
debug_variable (tree var)
{
dump_variable (stderr, var);
}
/* Dump various DFA statistics to FILE. */
void
dump_dfa_stats (FILE *file)
{
struct dfa_stats_d dfa_stats;
unsigned long size, total = 0;
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_3 = "%-43s%11lu%c\n";
const char *funcname
= lang_hooks.decl_printable_name (current_function_decl, 2);
collect_dfa_stats (&dfa_stats);
fprintf (file, "\nDFA Statistics for %s\n\n", funcname);
fprintf (file, "---------------------------------------------------------\n");
fprintf (file, fmt_str, "", " Number of ", "Memory");
fprintf (file, fmt_str, "", " instances ", "used ");
fprintf (file, "---------------------------------------------------------\n");
size = num_referenced_vars * sizeof (tree);
total += size;
fprintf (file, fmt_str_1, "Referenced variables", (unsigned long)num_referenced_vars,
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,
SCALE (size), LABEL (size));
size = dfa_stats.num_uses * sizeof (tree *);
total += size;
fprintf (file, fmt_str_1, "USE operands", dfa_stats.num_uses,
SCALE (size), LABEL (size));
size = dfa_stats.num_defs * sizeof (tree *);
total += size;
fprintf (file, fmt_str_1, "DEF operands", dfa_stats.num_defs,
SCALE (size), LABEL (size));
size = dfa_stats.num_vuses * sizeof (tree *);
total += size;
fprintf (file, fmt_str_1, "VUSE operands", dfa_stats.num_vuses,
SCALE (size), LABEL (size));
size = dfa_stats.num_vdefs * sizeof (tree *);
total += size;
fprintf (file, fmt_str_1, "VDEF operands", dfa_stats.num_vdefs,
SCALE (size), LABEL (size));
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));
size = dfa_stats.num_phi_args * sizeof (struct phi_arg_d);
total += size;
fprintf (file, fmt_str_1, "PHI arguments", dfa_stats.num_phi_args,
SCALE (size), LABEL (size));
fprintf (file, "---------------------------------------------------------\n");
fprintf (file, fmt_str_3, "Total memory used by DFA/SSA data", SCALE (total),
LABEL (total));
fprintf (file, "---------------------------------------------------------\n");
fprintf (file, "\n");
if (dfa_stats.num_phis)
fprintf (file, "Average number of arguments per PHI node: %.1f (max: %ld)\n",
(float) dfa_stats.num_phi_args / (float) dfa_stats.num_phis,
(long) dfa_stats.max_num_phi_args);
fprintf (file, "\n");
}
/* Dump DFA statistics on stderr. */
DEBUG_FUNCTION void
debug_dfa_stats (void)
{
dump_dfa_stats (stderr);
}
/* Collect DFA statistics and store them in the structure pointed to by
DFA_STATS_P. */
static void
collect_dfa_stats (struct dfa_stats_d *dfa_stats_p ATTRIBUTE_UNUSED)
{
basic_block bb;
referenced_var_iterator vi;
tree var;
gcc_assert (dfa_stats_p);
memset ((void *)dfa_stats_p, 0, sizeof (struct dfa_stats_d));
/* Count all the variable annotations. */
FOR_EACH_REFERENCED_VAR (var, vi)
if (var_ann (var))
dfa_stats_p->num_var_anns++;
/* Walk all the statements in the function counting references. */
FOR_EACH_BB (bb)
{
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 += 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);
}
for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
{
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;
}
}
}
/*---------------------------------------------------------------------------
Miscellaneous helpers
---------------------------------------------------------------------------*/
/* Callback for walk_tree. Used to collect variables referenced in
the function. */
static tree
find_vars_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
{
/* 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));
/* 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);
/* Type, _DECL and constant nodes have no interesting children.
Ignore them. */
else if (IS_TYPE_OR_DECL_P (*tp) || CONSTANT_CLASS_P (*tp))
*walk_subtrees = 0;
return NULL_TREE;
}
/* Find referenced variables in STMT. In contrast with
find_new_referenced_vars, this function will not mark newly found
variables for renaming. */
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, NULL, NULL);
}
else
{
walk_tree (gimple_phi_result_ptr (stmt), find_vars_r, NULL, 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, NULL, NULL);
}
}
}
/* Lookup UID in the referenced_vars hashtable and return the associated
variable. */
tree
referenced_var_lookup (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);
return h;
}
/* Check if TO is in the referenced_vars hash table and insert it if not.
Return true if it required insertion. */
bool
referenced_var_check_and_insert (tree to)
{
tree h, *loc;
struct tree_decl_minimal in;
unsigned int uid = DECL_UID (to);
in.uid = uid;
h = (tree) htab_find_with_hash (gimple_referenced_vars (cfun), &in, uid);
if (h)
{
/* DECL_UID has already been entered in the table. Verify that it is
the same entry as TO. See PR 27793. */
gcc_assert (h == to);
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
gimple_default_def (struct function *fn, tree var)
{
struct tree_decl_minimal ind;
struct tree_ssa_name in;
gcc_assert (SSA_VAR_P (var));
in.var = (tree)&ind;
ind.uid = DECL_UID (var);
return (tree) htab_find_with_hash (DEFAULT_DEFS (fn), &in, DECL_UID (var));
}
/* Insert the pair VAR's UID, DEF into the default_defs hashtable. */
void
set_default_def (tree var, tree def)
{
struct tree_decl_minimal ind;
struct tree_ssa_name in;
void **loc;
gcc_assert (SSA_VAR_P (var));
in.var = (tree)&ind;
ind.uid = DECL_UID (var);
if (!def)
{
loc = htab_find_slot_with_hash (DEFAULT_DEFS (cfun), &in,
DECL_UID (var), INSERT);
gcc_assert (*loc);
htab_remove_elt (DEFAULT_DEFS (cfun), *loc);
return;
}
gcc_assert (TREE_CODE (def) == SSA_NAME && SSA_NAME_VAR (def) == var);
loc = htab_find_slot_with_hash (DEFAULT_DEFS (cfun), &in,
DECL_UID (var), INSERT);
/* Default definition might be changed by tail call optimization. */
if (*loc)
SSA_NAME_IS_DEFAULT_DEF (*(tree *) loc) = false;
*(tree *) loc = def;
/* Mark DEF as the default definition for VAR. */
SSA_NAME_IS_DEFAULT_DEF (def) = true;
}
/* Add VAR to the list of referenced variables if it isn't already there. */
bool
add_referenced_var (tree var)
{
get_var_ann (var);
gcc_assert (DECL_P (var));
/* Insert VAR into the referenced_vars has table if it isn't present. */
if (referenced_var_check_and_insert (var))
{
/* Scan DECL_INITIAL for pointer variables as they may contain
address arithmetic referencing the address of other
variables. As we are only interested in directly referenced
globals or referenced locals restrict this to initializers
than can refer to local variables. */
if (DECL_INITIAL (var)
&& DECL_CONTEXT (var) == current_function_decl)
walk_tree (&DECL_INITIAL (var), find_vars_r, NULL, 0);
return true;
}
return false;
}
/* Remove VAR from the list. */
void
remove_referenced_var (tree var)
{
var_ann_t v_ann;
struct tree_decl_minimal in;
void **loc;
unsigned int uid = DECL_UID (var);
/* Preserve var_anns of globals. */
if (!is_global_var (var)
&& (v_ann = var_ann (var)))
{
ggc_free (v_ann);
*DECL_VAR_ANN_PTR (var) = NULL;
}
gcc_assert (DECL_P (var));
in.uid = uid;
loc = htab_find_slot_with_hash (gimple_referenced_vars (cfun), &in, uid,
NO_INSERT);
htab_clear_slot (gimple_referenced_vars (cfun), loc);
}
/* 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. */
void
mark_symbols_for_renaming (gimple 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;
}
/* Find any new referenced variables in STMT. */
void
find_new_referenced_vars (gimple stmt)
{
walk_gimple_op (stmt, find_new_referenced_vars_1, 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
*PSIZE or *PMAX_SIZE is -1, they could not be determined. If *PSIZE
and *PMAX_SIZE are equal, the access is non-variable. */
tree
get_ref_base_and_extent (tree exp, HOST_WIDE_INT *poffset,
HOST_WIDE_INT *psize,
HOST_WIDE_INT *pmax_size)
{
HOST_WIDE_INT bitsize = -1;
HOST_WIDE_INT maxsize = -1;
tree size_tree = NULL_TREE;
HOST_WIDE_INT bit_offset = 0;
bool seen_variable_array_ref = false;
/* 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 if (!VOID_TYPE_P (TREE_TYPE (exp)))
{
enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
if (mode == BLKmode)
size_tree = TYPE_SIZE (TREE_TYPE (exp));
else
bitsize = GET_MODE_BITSIZE (mode);
}
if (size_tree != NULL_TREE)
{
if (! host_integerp (size_tree, 1))
bitsize = -1;
else
bitsize = TREE_INT_CST_LOW (size_tree);
}
/* Initially, maxsize is the same as the accessed element size.
In the following it will only grow (or become -1). */
maxsize = bitsize;
/* Compute cumulative bit-offset for nested component-refs and array-refs,
and find the ultimate containing object. */
while (1)
{
switch (TREE_CODE (exp))
{
case BIT_FIELD_REF:
bit_offset += TREE_INT_CST_LOW (TREE_OPERAND (exp, 2));
break;
case COMPONENT_REF:
{
tree field = TREE_OPERAND (exp, 1);
tree this_offset = component_ref_field_offset (exp);
if (this_offset
&& TREE_CODE (this_offset) == INTEGER_CST
&& host_integerp (this_offset, 0))
{
HOST_WIDE_INT hthis_offset = TREE_INT_CST_LOW (this_offset);
hthis_offset *= BITS_PER_UNIT;
hthis_offset
+= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (field));
bit_offset += hthis_offset;
/* 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))
maxsize += ((TREE_INT_CST_LOW (ssize)
- TREE_INT_CST_LOW (fsize))
* BITS_PER_UNIT - hthis_offset);
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 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;
else
maxsize = -1;
}
}
break;
case ARRAY_REF:
case ARRAY_RANGE_REF:
{
tree index = TREE_OPERAND (exp, 1);
tree low_bound, unit_size;
/* If the resulting bit-offset is constant, track it. */
if (TREE_CODE (index) == INTEGER_CST
&& host_integerp (index, 0)
&& (low_bound = array_ref_low_bound (exp),
host_integerp (low_bound, 0))
&& (unit_size = array_ref_element_size (exp),
host_integerp (unit_size, 1)))
{
HOST_WIDE_INT hindex = TREE_INT_CST_LOW (index);
hindex -= TREE_INT_CST_LOW (low_bound);
hindex *= TREE_INT_CST_LOW (unit_size);
hindex *= BITS_PER_UNIT;
bit_offset += hindex;
/* An array ref with a constant index up in the structure
hierarchy will constrain the size of any variable array ref
lower in the access hierarchy. */
seen_variable_array_ref = false;
}
else
{
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 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;
else
maxsize = -1;
/* Remember that we have seen an array ref with a variable
index. */
seen_variable_array_ref = true;
}
}
break;
case REALPART_EXPR:
break;
case IMAGPART_EXPR:
bit_offset += bitsize;
break;
case VIEW_CONVERT_EXPR:
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, shwi_to_double_int (bit_offset));
if (double_int_fits_in_shwi_p (off))
{
bit_offset = double_int_to_shwi (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 = 0;
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, shwi_to_double_int (bit_offset));
if (double_int_fits_in_shwi_p (off))
{
bit_offset = double_int_to_shwi (off);
exp = TREE_OPERAND (TMR_BASE (exp), 0);
}
}
}
goto done;
default:
goto done;
}
exp = TREE_OPERAND (exp, 0);
}
done:
/* 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. This needs to include possible trailing padding
that is there for alignment purposes.
That is of course only true if the base object is not a decl. */
if (DECL_P (exp))
{
/* If maxsize is unknown adjust it according to the size of the
base decl. */
if (maxsize == -1
&& host_integerp (DECL_SIZE (exp), 1))
maxsize = TREE_INT_CST_LOW (DECL_SIZE (exp)) - bit_offset;
}
else if (seen_variable_array_ref
&& maxsize != -1
&& (!host_integerp (TYPE_SIZE (TREE_TYPE (exp)), 1)
|| (bit_offset + maxsize
== (signed) TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (exp))))))
maxsize = -1;
/* ??? Due to negative offsets in ARRAY_REF we can end up with
negative bit_offset here. We might want to store a zero offset
in this case. */
*poffset = bit_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)
{
HOST_WIDE_INT byte_offset = 0;
/* Compute cumulative byte-offset for nested component-refs and array-refs,
and find the ultimate containing object. */
while (1)
{
switch (TREE_CODE (exp))
{
case BIT_FIELD_REF:
return NULL_TREE;
case COMPONENT_REF:
{
tree field = TREE_OPERAND (exp, 1);
tree this_offset = component_ref_field_offset (exp);
HOST_WIDE_INT hthis_offset;
if (!this_offset
|| TREE_CODE (this_offset) != INTEGER_CST
|| (TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (field))
% BITS_PER_UNIT))
return NULL_TREE;
hthis_offset = TREE_INT_CST_LOW (this_offset);
hthis_offset += (TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (field))
/ BITS_PER_UNIT);
byte_offset += hthis_offset;
}
break;
case ARRAY_REF:
case ARRAY_RANGE_REF:
{
tree index = TREE_OPERAND (exp, 1);
tree low_bound, unit_size;
/* If the resulting bit-offset is constant, track it. */
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_INT_CST_LOW (index);
hindex -= TREE_INT_CST_LOW (low_bound);
hindex *= TREE_INT_CST_LOW (unit_size);
byte_offset += hindex;
}
else
return NULL_TREE;
}
break;
case REALPART_EXPR:
break;
case IMAGPART_EXPR:
byte_offset += TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (exp)));
break;
case VIEW_CONVERT_EXPR:
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)))
{
double_int off = mem_ref_offset (exp);
gcc_assert (off.high == -1 || off.high == 0);
byte_offset += double_int_to_shwi (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)
{
if (TMR_INDEX (exp) || TMR_INDEX2 (exp))
return NULL_TREE;
if (!integer_zerop (TMR_OFFSET (exp)))
{
double_int off = mem_ref_offset (exp);
gcc_assert (off.high == -1 || off.high == 0);
byte_offset += double_int_to_shwi (off);
}
exp = TREE_OPERAND (TMR_BASE (exp), 0);
}
goto done;
default:
goto done;
}
exp = TREE_OPERAND (exp, 0);
}
done:
*poffset = byte_offset;
return exp;
}
/* 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 (gimple stmt)
{
ssa_op_iter oi;
use_operand_p use_p;
FOR_EACH_SSA_USE_OPERAND (use_p, stmt, oi, SSA_OP_USE)
{
if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (USE_FROM_PTR (use_p)))
return true;
}
return false;
}
Reference in New Issue View Git Blame Copy Permalink