/* Data flow functions for trees.
- Copyright (C) 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+ Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007 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 2, or (at your option)
+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,
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 COPYING. If not, write to
-the Free Software Foundation, 51 Franklin Street, Fifth Floor,
-Boston, MA 02110-1301, USA. */
+along with GCC; see the file COPYING3. If not see
+<http://www.gnu.org/licenses/>. */
#include "config.h"
#include "system.h"
ann = var_ann (var);
- fprintf (file, ", UID %u", (unsigned) DECL_UID (var));
+ fprintf (file, ", UID D.%u", (unsigned) DECL_UID (var));
fprintf (file, ", ");
print_generic_expr (file, TREE_TYPE (var), dump_flags);
if (TREE_THIS_VOLATILE (var))
fprintf (file, ", is volatile");
+ if (mem_sym_stats (cfun, var))
+ {
+ mem_sym_stats_t stats = mem_sym_stats (cfun, var);
+ fprintf (file, ", direct reads: %ld", stats->num_direct_reads);
+ fprintf (file, ", direct writes: %ld", stats->num_direct_writes);
+ fprintf (file, ", indirect reads: %ld", stats->num_indirect_reads);
+ fprintf (file, ", indirect writes: %ld", stats->num_indirect_writes);
+ fprintf (file, ", read frequency: %ld", stats->frequency_reads);
+ fprintf (file, ", write frequency: %ld", stats->frequency_writes);
+ }
+
if (is_call_clobbered (var))
{
+ const char *s = "";
var_ann_t va = var_ann (var);
unsigned int escape_mask = va->escape_mask;
fprintf (file, ", call clobbered");
fprintf (file, " (");
if (escape_mask & ESCAPE_STORED_IN_GLOBAL)
- fprintf (file, ", stored in global");
+ { fprintf (file, "%sstored in global", s); s = ", "; }
if (escape_mask & ESCAPE_TO_ASM)
- fprintf (file, ", goes through ASM");
+ { fprintf (file, "%sgoes through ASM", s); s = ", "; }
if (escape_mask & ESCAPE_TO_CALL)
- fprintf (file, ", passed to call");
+ { fprintf (file, "%spassed to call", s); s = ", "; }
if (escape_mask & ESCAPE_BAD_CAST)
- fprintf (file, ", bad cast");
+ { fprintf (file, "%sbad cast", s); s = ", "; }
if (escape_mask & ESCAPE_TO_RETURN)
- fprintf (file, ", returned from func");
+ { fprintf (file, "%sreturned from func", s); s = ", "; }
if (escape_mask & ESCAPE_TO_PURE_CONST)
- fprintf (file, ", passed to pure/const");
+ { fprintf (file, "%spassed to pure/const", s); s = ", "; }
if (escape_mask & ESCAPE_IS_GLOBAL)
- fprintf (file, ", is global var");
+ { fprintf (file, "%sis global var", s); s = ", "; }
if (escape_mask & ESCAPE_IS_PARM)
- fprintf (file, ", is incoming pointer");
+ { fprintf (file, "%sis incoming pointer", s); s = ", "; }
if (escape_mask & ESCAPE_UNKNOWN)
- fprintf (file, ", unknown escape");
- fprintf (file, " )");
+ { 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))
{
fprintf (file, ", default def: ");
tree
referenced_var_lookup (unsigned int uid)
{
- struct int_tree_map *h, in;
+ tree h;
+ struct tree_decl_minimal in;
in.uid = uid;
- h = (struct int_tree_map *) htab_find_with_hash (gimple_referenced_vars (cfun),
- &in, uid);
+ h = (tree) htab_find_with_hash (gimple_referenced_vars (cfun), &in, uid);
gcc_assert (h || uid == 0);
- if (h)
- return h->to;
- return NULL_TREE;
+ return h;
}
/* Check if TO is in the referenced_vars hash table and insert it if not.
bool
referenced_var_check_and_insert (tree to)
{
- struct int_tree_map *h, in;
- void **loc;
+ tree h, *loc;
+ struct tree_decl_minimal in;
unsigned int uid = DECL_UID (to);
in.uid = uid;
- in.to = to;
- h = (struct int_tree_map *) htab_find_with_hash (gimple_referenced_vars (cfun),
- &in, uid);
-
+ 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 == to);
+ gcc_assert (h == to);
return false;
}
- h = GGC_NEW (struct int_tree_map);
- h->uid = uid;
- h->to = to;
- loc = htab_find_slot_with_hash (gimple_referenced_vars (cfun),
- h, uid, INSERT);
- *(struct int_tree_map **) loc = h;
+ loc = (tree *) htab_find_slot_with_hash (gimple_referenced_vars (cfun),
+ &in, uid, INSERT);
+ *loc = to;
return true;
}
tree
gimple_default_def (struct function *fn, tree var)
{
- struct int_tree_map *h, in;
+ struct tree_decl_minimal ind;
+ struct tree_ssa_name in;
gcc_assert (SSA_VAR_P (var));
- in.uid = DECL_UID (var);
- h = (struct int_tree_map *) htab_find_with_hash (DEFAULT_DEFS (fn),
- &in,
- DECL_UID (var));
- if (h)
- return h->to;
- return NULL_TREE;
+ 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 int_tree_map in;
- struct int_tree_map *h;
+ struct tree_decl_minimal ind;
+ struct tree_ssa_name in;
void **loc;
gcc_assert (SSA_VAR_P (var));
- in.uid = DECL_UID (var);
- if (!def && gimple_default_def (cfun, 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 (!def || TREE_CODE (def) == SSA_NAME);
+ 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)
- {
- h = GGC_NEW (struct int_tree_map);
- h->uid = DECL_UID (var);
- h->to = def;
- *(struct int_tree_map **) loc = h;
- }
- else
- {
- h = (struct int_tree_map *) *loc;
- SSA_NAME_IS_DEFAULT_DEF (h->to) = false;
- h->to = def;
- }
+ 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;
remove_referenced_var (tree var)
{
var_ann_t v_ann;
- struct int_tree_map in;
+ struct tree_decl_minimal in;
void **loc;
unsigned int uid = DECL_UID (var);
var->base.ann = NULL;
gcc_assert (DECL_P (var));
in.uid = uid;
- in.to = var;
loc = htab_find_slot_with_hash (gimple_referenced_vars (cfun), &in, uid,
NO_INSERT);
- ggc_free (*loc);
htab_clear_slot (gimple_referenced_vars (cfun), loc);
}
switch (TREE_CODE (exp))
{
case BIT_FIELD_REF:
- bit_offset += tree_low_cst (TREE_OPERAND (exp, 2), 1);
+ bit_offset += tree_low_cst (TREE_OPERAND (exp, 2), 0);
break;
case COMPONENT_REF:
if (this_offset && TREE_CODE (this_offset) == INTEGER_CST)
{
- HOST_WIDE_INT hthis_offset = tree_low_cst (this_offset, 1);
+ 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), 1);
+ bit_offset += tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 0);
}
else
{
/* We need to adjust maxsize to the whole structure bitsize.
But we can subtract any constant offset seen sofar,
because that would get us out of the structure otherwise. */
- if (maxsize != -1
- && csize && host_integerp (csize, 1))
- {
- maxsize = (TREE_INT_CST_LOW (csize) - bit_offset);
- }
+ if (maxsize != -1 && csize && host_integerp (csize, 1))
+ maxsize = TREE_INT_CST_LOW (csize) - bit_offset;
else
maxsize = -1;
}
/* We need to adjust maxsize to the whole array bitsize.
But we can subtract any constant offset seen sofar,
because that would get us outside of the array otherwise. */
- if (maxsize != -1
- && asize && host_integerp (asize, 1))
- {
- maxsize = (TREE_INT_CST_LOW (asize) - bit_offset);
- }
+ if (maxsize != -1 && asize && host_integerp (asize, 1))
+ maxsize = TREE_INT_CST_LOW (asize) - bit_offset;
else
maxsize = -1;
return exp;
}
+
+
+/* Return memory reference statistics for variable VAR in function FN.
+ This is computed by alias analysis, but it is not kept
+ incrementally up-to-date. So, these stats are only accurate if
+ pass_may_alias has been run recently. If no alias information
+ exists, this function returns NULL. */
+
+mem_sym_stats_t
+mem_sym_stats (struct function *fn, tree var)
+{
+ void **slot;
+ struct pointer_map_t *stats_map = gimple_mem_ref_stats (fn)->mem_sym_stats;
+
+ if (stats_map == NULL)
+ return NULL;
+
+ slot = pointer_map_contains (stats_map, var);
+ if (slot == NULL)
+ return NULL;
+
+ return (mem_sym_stats_t) *slot;
+}
OSDN Git Service
