/* Alias analysis for GNU C
- Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
- Free Software Foundation, Inc.
+ Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
+ 2007 Free Software Foundation, Inc.
Contributed by John Carr (jfc@mit.edu).
This file is part of GCC.
#include "varray.h"
#include "tree-pass.h"
#include "ipa-type-escape.h"
+#include "df.h"
/* The aliasing API provided here solves related but different problems:
- Say there exists (in c)
+ Say there exists (in c)
struct X {
struct Y y1;
this may be too conservative for some C++ types.
The pass ipa-type-escape does this analysis for the types whose
- instances do not escape across the compilation boundary.
+ instances do not escape across the compilation boundary.
Historically in GCC, these two problems were combined and a single
data structure was used to represent the solution to these
`double'. (However, a store to an `int' cannot alias a `double'
and vice versa.) We indicate this via a tree structure that looks
like:
- struct S
- / \
+ struct S
+ / \
/ \
- |/_ _\|
- int double
+ |/_ _\|
+ int double
(The arrows are directed and point downwards.)
In this situation we say the alias set for `struct S' is the
typedef struct alias_set_entry *alias_set_entry;
static int rtx_equal_for_memref_p (rtx, rtx);
-static rtx find_symbolic_term (rtx);
static int memrefs_conflict_p (int, rtx, int, rtx, HOST_WIDE_INT);
static void record_set (rtx, rtx, void *);
static int base_alias_check (rtx, rtx, enum machine_mode,
current function performs nonlocal memory memory references for the
purposes of marking the function as a constant function. */
-static GTY(()) varray_type reg_base_value;
+static GTY(()) VEC(rtx,gc) *reg_base_value;
static rtx *new_reg_base_value;
/* We preserve the copy of old array around to avoid amount of garbage
produced. About 8% of garbage produced were attributed to this
array. */
-static GTY((deletable)) varray_type old_reg_base_value;
+static GTY((deletable)) VEC(rtx,gc) *old_reg_base_value;
/* Static hunks of RTL used by the aliasing code; these are initialized
once per function to avoid unnecessary RTL allocations. */
static GTY (()) rtx static_reg_base_value[FIRST_PSEUDO_REGISTER];
-#define REG_BASE_VALUE(X) \
- (reg_base_value && REGNO (X) < VARRAY_SIZE (reg_base_value) \
- ? VARRAY_RTX (reg_base_value, REGNO (X)) : 0)
-
-/* Vector of known invariant relationships between registers. Set in
- loop unrolling. Indexed by register number, if nonzero the value
- is an expression describing this register in terms of another.
-
- The length of this array is REG_BASE_VALUE_SIZE.
-
- Because this array contains only pseudo registers it has no effect
- after reload. */
-static GTY((length("alias_invariant_size"))) rtx *alias_invariant;
-static GTY(()) unsigned int alias_invariant_size;
+#define REG_BASE_VALUE(X) \
+ (REGNO (X) < VEC_length (rtx, reg_base_value) \
+ ? VEC_index (rtx, reg_base_value, REGNO (X)) : 0)
/* Vector indexed by N giving the initial (unchanging) value known for
pseudo-register N. This array is initialized in init_alias_analysis,
NOTE_INSN_FUNCTION_BEG note. */
static bool copying_arguments;
+DEF_VEC_P(alias_set_entry);
+DEF_VEC_ALLOC_P(alias_set_entry,gc);
+
/* The splay-tree used to store the various alias set entries. */
-static GTY ((param_is (struct alias_set_entry))) varray_type alias_sets;
+static GTY (()) VEC(alias_set_entry,gc) *alias_sets;
\f
/* Returns a pointer to the alias set entry for ALIAS_SET, if there is
such an entry, or NULL otherwise. */
static inline alias_set_entry
get_alias_set_entry (HOST_WIDE_INT alias_set)
{
- return (alias_set_entry)VARRAY_GENERIC_PTR (alias_sets, alias_set);
+ return VEC_index (alias_set_entry, alias_sets, alias_set);
}
/* Returns nonzero if the alias sets for MEM1 and MEM2 are such that
return 0;
}
+/* Return true if the first alias set is a subset of the second. */
+
+bool
+alias_set_subset_of (HOST_WIDE_INT set1, HOST_WIDE_INT set2)
+{
+ alias_set_entry ase;
+
+ /* Everything is a subset of the "aliases everything" set. */
+ if (set2 == 0)
+ return true;
+
+ /* Otherwise, check if set1 is a subset of set2. */
+ ase = get_alias_set_entry (set2);
+ if (ase != 0
+ && (splay_tree_lookup (ase->children,
+ (splay_tree_key) set1)))
+ return true;
+ return false;
+}
+
/* Return 1 if the two specified alias sets may conflict. */
int
{
alias_set_entry ase;
- /* If have no alias set information for one of the operands, we have
- to assume it can alias anything. */
- if (set1 == 0 || set2 == 0
- /* If the two alias sets are the same, they may alias. */
- || set1 == set2)
+ /* The easy case. */
+ if (alias_sets_must_conflict_p (set1, set2))
return 1;
/* See if the first alias set is a subset of the second. */
return 1;
/* The two alias sets are distinct and neither one is the
- child of the other. Therefore, they cannot alias. */
+ child of the other. Therefore, they cannot conflict. */
return 0;
}
-/* Return 1 if the two specified alias sets might conflict, or if any subtype
- of these alias sets might conflict. */
+/* Return 1 if the two specified alias sets will always conflict. */
int
-alias_sets_might_conflict_p (HOST_WIDE_INT set1, HOST_WIDE_INT set2)
+alias_sets_must_conflict_p (HOST_WIDE_INT set1, HOST_WIDE_INT set2)
{
if (set1 == 0 || set2 == 0 || set1 == set2)
return 1;
return 0;
}
-\f
/* Return 1 if any MEM object of type T1 will always conflict (using the
dependency routines in this file) with any MEM object of type T2.
This is used when allocating temporary storage. If T1 and/or T2 are
set1 = t1 ? get_alias_set (t1) : 0;
set2 = t2 ? get_alias_set (t2) : 0;
- /* Otherwise they conflict if they have no alias set or the same. We
- can't simply use alias_sets_conflict_p here, because we must make
- sure that every subtype of t1 will conflict with every subtype of
+ /* We can't use alias_sets_conflict_p because we must make sure
+ that every subtype of t1 will conflict with every subtype of
t2 for which a pair of subobjects of these respective subtypes
overlaps on the stack. */
- return set1 == 0 || set2 == 0 || set1 == set2;
+ return alias_sets_must_conflict_p (set1, set2);
}
\f
/* T is an expression with pointer type. Find the DECL on which this
return 0;
}
+ /* For non-addressable fields we return the alias set of the
+ outermost object that could have its address taken. If this
+ is an SFT use the precomputed value. */
+ if (TREE_CODE (t) == STRUCT_FIELD_TAG
+ && SFT_NONADDRESSABLE_P (t))
+ return SFT_ALIAS_SET (t);
+
/* Otherwise, pick up the outermost object that we could have a pointer
to, processing conversions as above. */
while (component_uses_parent_alias_set (t))
/* There are no objects of FUNCTION_TYPE, so there's no point in
using up an alias set for them. (There are, of course, pointers
and references to functions, but that's different.) */
- else if (TREE_CODE (t) == FUNCTION_TYPE)
+ else if (TREE_CODE (t) == FUNCTION_TYPE
+ || TREE_CODE (t) == METHOD_TYPE)
set = 0;
/* Unless the language specifies otherwise, let vector types alias
/* Return a brand-new alias set. */
-static GTY(()) HOST_WIDE_INT last_alias_set;
-
HOST_WIDE_INT
new_alias_set (void)
{
if (flag_strict_aliasing)
{
- if (!alias_sets)
- VARRAY_GENERIC_PTR_INIT (alias_sets, 10, "alias sets");
- else
- VARRAY_GROW (alias_sets, last_alias_set + 2);
- return ++last_alias_set;
+ if (alias_sets == 0)
+ VEC_safe_push (alias_set_entry, gc, alias_sets, 0);
+ VEC_safe_push (alias_set_entry, gc, alias_sets, 0);
+ return VEC_length (alias_set_entry, alias_sets) - 1;
}
else
return 0;
superset_entry->children
= splay_tree_new_ggc (splay_tree_compare_ints);
superset_entry->has_zero_child = 0;
- VARRAY_GENERIC_PTR (alias_sets, superset) = superset_entry;
+ VEC_replace (alias_set_entry, alias_sets, superset, superset_entry);
}
if (subset == 0)
{
int i;
tree binfo, base_binfo;
-
+
for (binfo = TYPE_BINFO (type), i = 0;
BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
record_alias_subset (superset,
The test above is not sufficient because the scheduler may move
a copy out of an arg reg past the NOTE_INSN_FUNCTION_BEGIN. */
if ((regno >= FIRST_PSEUDO_REGISTER || fixed_regs[regno])
- && regno < VARRAY_SIZE (reg_base_value))
+ && regno < VEC_length (rtx, reg_base_value))
{
/* If we're inside init_alias_analysis, use new_reg_base_value
to reduce the number of relaxation iterations. */
if (new_reg_base_value && new_reg_base_value[regno]
- && REG_N_SETS (regno) == 1)
+ && DF_REG_DEF_COUNT (regno) == 1)
return new_reg_base_value[regno];
- if (VARRAY_RTX (reg_base_value, regno))
- return VARRAY_RTX (reg_base_value, regno);
+ if (VEC_index (rtx, reg_base_value, regno))
+ return VEC_index (rtx, reg_base_value, regno);
}
return 0;
regno = REGNO (dest);
- gcc_assert (regno < VARRAY_SIZE (reg_base_value));
+ gcc_assert (regno < VEC_length (rtx, reg_base_value));
/* If this spans multiple hard registers, then we must indicate that every
register has an unusable value. */
If neither case holds, reject the original base value as invalid.
Note that the following situation is not detected:
- extern int x, y; int *p = &x; p += (&y-&x);
+ extern int x, y; int *p = &x; p += (&y-&x);
ANSI C does not allow computing the difference of addresses
of distinct top level objects. */
reg_seen[regno] = 1;
}
-/* Called from loop optimization when a new pseudo-register is
- created. It indicates that REGNO is being set to VAL. f INVARIANT
- is true then this value also describes an invariant relationship
- which can be used to deduce that two registers with unknown values
- are different. */
-
-void
-record_base_value (unsigned int regno, rtx val, int invariant)
-{
- if (invariant && alias_invariant && regno < alias_invariant_size)
- alias_invariant[regno] = val;
-
- if (regno >= VARRAY_SIZE (reg_base_value))
- VARRAY_GROW (reg_base_value, max_reg_num ());
-
- if (REG_P (val))
- {
- VARRAY_RTX (reg_base_value, regno)
- = REG_BASE_VALUE (val);
- return;
- }
- VARRAY_RTX (reg_base_value, regno)
- = find_base_value (val);
-}
-
-/* Clear alias info for a register. This is used if an RTL transformation
- changes the value of a register. This is used in flow by AUTO_INC_DEC
- optimizations. We don't need to clear reg_base_value, since flow only
- changes the offset. */
-
-void
-clear_reg_alias_info (rtx reg)
-{
- unsigned int regno = REGNO (reg);
-
- if (regno >= FIRST_PSEUDO_REGISTER)
- {
- regno -= FIRST_PSEUDO_REGISTER;
- if (regno < reg_known_value_size)
- {
- reg_known_value[regno] = reg;
- reg_known_equiv_p[regno] = false;
- }
- }
-}
-
/* If a value is known for REGNO, return it. */
-rtx
+rtx
get_reg_known_value (unsigned int regno)
{
if (regno >= FIRST_PSEUDO_REGISTER)
return 1;
}
-/* Given an rtx X, find a SYMBOL_REF or LABEL_REF within
- X and return it, or return 0 if none found. */
-
-static rtx
-find_symbolic_term (rtx x)
-{
- int i;
- enum rtx_code code;
- const char *fmt;
-
- code = GET_CODE (x);
- if (code == SYMBOL_REF || code == LABEL_REF)
- return x;
- if (OBJECT_P (x))
- return 0;
-
- fmt = GET_RTX_FORMAT (code);
- for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
- {
- rtx t;
-
- if (fmt[i] == 'e')
- {
- t = find_symbolic_term (XEXP (x, i));
- if (t != 0)
- return t;
- }
- else if (fmt[i] == 'E')
- break;
- }
- return 0;
-}
-
rtx
find_base_term (rtx x)
{
if (offset)
addr = gen_rtx_PLUS (GET_MODE (addr), XEXP (addr, 0),
- GEN_INT (offset));
+ GEN_INT (offset));
else
addr = XEXP (addr, 0);
addr = canon_rtx (addr);
return memrefs_conflict_p (xsize, x0, ysize, y0, c);
}
- case REG:
- /* Are these registers known not to be equal? */
- if (alias_invariant)
- {
- unsigned int r_x = REGNO (x), r_y = REGNO (y);
- rtx i_x, i_y; /* invariant relationships of X and Y */
-
- i_x = r_x >= alias_invariant_size ? 0 : alias_invariant[r_x];
- i_y = r_y >= alias_invariant_size ? 0 : alias_invariant[r_y];
-
- if (i_x == 0 && i_y == 0)
- break;
-
- if (! memrefs_conflict_p (xsize, i_x ? i_x : x,
- ysize, i_y ? i_y : y, c))
- return 0;
- }
- break;
-
default:
break;
}
if (! flag_strict_aliasing)
return NULL_RTX;
- if (MEM_SCALAR_P (mem1) && MEM_IN_STRUCT_P (mem2)
+ if (MEM_ALIAS_SET (mem2)
+ && MEM_SCALAR_P (mem1) && MEM_IN_STRUCT_P (mem2)
&& !varies_p (mem1_addr, 1) && varies_p (mem2_addr, 1))
/* MEM1 is a scalar at a fixed address; MEM2 is a struct at a
varying address. */
return mem1;
- if (MEM_IN_STRUCT_P (mem1) && MEM_SCALAR_P (mem2)
+ if (MEM_ALIAS_SET (mem1)
+ && MEM_IN_STRUCT_P (mem1) && MEM_SCALAR_P (mem2)
&& varies_p (mem1_addr, 1) && !varies_p (mem2_addr, 1))
/* MEM2 is a scalar at a fixed address; MEM1 is a struct at a
varying address. */
/* Unless both have exprs, we can't tell anything. */
if (exprx == 0 || expry == 0)
return 0;
-
+
/* If both are field references, we may be able to determine something. */
if (TREE_CODE (exprx) == COMPONENT_REF
&& TREE_CODE (expry) == COMPONENT_REF
&& nonoverlapping_component_refs_p (exprx, expry))
return 1;
-
+
/* If the field reference test failed, look at the DECLs involved. */
moffsetx = MEM_OFFSET (x);
if (TREE_CODE (exprx) == COMPONENT_REF)
tree fieldcontext = DECL_FIELD_CONTEXT (field);
if (ipa_type_escape_field_does_not_clobber_p (fieldcontext,
TREE_TYPE (field)))
- return 1;
+ return 1;
}
{
tree t = decl_for_component_ref (exprx);
tree fieldcontext = DECL_FIELD_CONTEXT (field);
if (ipa_type_escape_field_does_not_clobber_p (fieldcontext,
TREE_TYPE (field)))
- return 1;
+ return 1;
}
{
tree t = decl_for_component_ref (expry);
return 1;
/* (mem:BLK (scratch)) is a special mechanism to conflict with everything.
- This is used in epilogue deallocation functions. */
+ This is used in epilogue deallocation functions, and in cselib. */
if (GET_MODE (x) == BLKmode && GET_CODE (XEXP (x, 0)) == SCRATCH)
return 1;
if (GET_MODE (mem) == BLKmode && GET_CODE (XEXP (mem, 0)) == SCRATCH)
return 1;
+ if (MEM_ALIAS_SET (x) == ALIAS_SET_MEMORY_BARRIER
+ || MEM_ALIAS_SET (mem) == ALIAS_SET_MEMORY_BARRIER)
+ return 1;
if (DIFFERENT_ALIAS_SETS_P (x, mem))
return 0;
return 1;
if (GET_MODE (mem) == BLKmode && GET_CODE (XEXP (mem, 0)) == SCRATCH)
return 1;
+ if (MEM_ALIAS_SET (x) == ALIAS_SET_MEMORY_BARRIER
+ || MEM_ALIAS_SET (mem) == ALIAS_SET_MEMORY_BARRIER)
+ return 1;
if (DIFFERENT_ALIAS_SETS_P (x, mem))
return 0;
return 1;
if (GET_MODE (mem) == BLKmode && GET_CODE (XEXP (mem, 0)) == SCRATCH)
return 1;
+ if (MEM_ALIAS_SET (x) == ALIAS_SET_MEMORY_BARRIER
+ || MEM_ALIAS_SET (mem) == ALIAS_SET_MEMORY_BARRIER)
+ return 1;
if (DIFFERENT_ALIAS_SETS_P (x, mem))
return 0;
reg_known_value = ggc_calloc (reg_known_value_size, sizeof (rtx));
reg_known_equiv_p = xcalloc (reg_known_value_size, sizeof (bool));
- /* Overallocate reg_base_value to allow some growth during loop
- optimization. Loop unrolling can create a large number of
- registers. */
+ /* If we have memory allocated from the previous run, use it. */
if (old_reg_base_value)
- {
- reg_base_value = old_reg_base_value;
- /* If varray gets large zeroing cost may get important. */
- if (VARRAY_SIZE (reg_base_value) > 256
- && VARRAY_SIZE (reg_base_value) > 4 * maxreg)
- VARRAY_GROW (reg_base_value, maxreg);
- VARRAY_CLEAR (reg_base_value);
- if (VARRAY_SIZE (reg_base_value) < maxreg)
- VARRAY_GROW (reg_base_value, maxreg);
- }
- else
- {
- VARRAY_RTX_INIT (reg_base_value, maxreg, "reg_base_value");
- }
+ reg_base_value = old_reg_base_value;
+
+ if (reg_base_value)
+ VEC_truncate (rtx, reg_base_value, 0);
- new_reg_base_value = xmalloc (maxreg * sizeof (rtx));
- reg_seen = xmalloc (maxreg);
+ VEC_safe_grow_cleared (rtx, gc, reg_base_value, maxreg);
+
+ new_reg_base_value = XNEWVEC (rtx, maxreg);
+ reg_seen = XNEWVEC (char, maxreg);
/* The basic idea is that each pass through this loop will use the
"constant" information from the previous pass to propagate alias
the optimization level or flag_expensive_optimizations.
We could propagate more information in the first pass by making use
- of REG_N_SETS to determine immediately that the alias information
+ of DF_REG_DEF_COUNT to determine immediately that the alias information
for a pseudo is "constant".
A program with an uninitialized variable can cause an infinite loop
#endif
/* If this insn has a noalias note, process it, Otherwise,
- scan for sets. A simple set will have no side effects
- which could change the base value of any other register. */
+ scan for sets. A simple set will have no side effects
+ which could change the base value of any other register. */
if (GET_CODE (PATTERN (insn)) == SET
&& REG_NOTES (insn) != 0
rtx src = SET_SRC (set);
rtx t;
- if (REG_NOTES (insn) != 0
- && (((note = find_reg_note (insn, REG_EQUAL, 0)) != 0
- && REG_N_SETS (regno) == 1)
- || (note = find_reg_note (insn, REG_EQUIV, NULL_RTX)) != 0)
+ note = find_reg_equal_equiv_note (insn);
+ if (note && REG_NOTE_KIND (note) == REG_EQUAL
+ && DF_REG_DEF_COUNT (regno) != 1)
+ note = NULL_RTX;
+
+ if (note != NULL_RTX
&& GET_CODE (XEXP (note, 0)) != EXPR_LIST
&& ! rtx_varies_p (XEXP (note, 0), 1)
&& ! reg_overlap_mentioned_p (SET_DEST (set),
set_reg_known_equiv_p (regno,
REG_NOTE_KIND (note) == REG_EQUIV);
}
- else if (REG_N_SETS (regno) == 1
+ else if (DF_REG_DEF_COUNT (regno) == 1
&& GET_CODE (src) == PLUS
&& REG_P (XEXP (src, 0))
&& (t = get_reg_known_value (REGNO (XEXP (src, 0))))
set_reg_known_value (regno, t);
set_reg_known_equiv_p (regno, 0);
}
- else if (REG_N_SETS (regno) == 1
+ else if (DF_REG_DEF_COUNT (regno) == 1
&& ! rtx_varies_p (src, 1))
{
set_reg_known_value (regno, src);
}
}
else if (NOTE_P (insn)
- && NOTE_LINE_NUMBER (insn) == NOTE_INSN_FUNCTION_BEG)
+ && NOTE_KIND (insn) == NOTE_INSN_FUNCTION_BEG)
copying_arguments = false;
}
/* Now propagate values from new_reg_base_value to reg_base_value. */
- gcc_assert (maxreg == (unsigned int) max_reg_num());
-
+ gcc_assert (maxreg == (unsigned int) max_reg_num ());
+
for (ui = 0; ui < maxreg; ui++)
{
if (new_reg_base_value[ui]
- && new_reg_base_value[ui] != VARRAY_RTX (reg_base_value, ui)
+ && new_reg_base_value[ui] != VEC_index (rtx, reg_base_value, ui)
&& ! rtx_equal_p (new_reg_base_value[ui],
- VARRAY_RTX (reg_base_value, ui)))
+ VEC_index (rtx, reg_base_value, ui)))
{
- VARRAY_RTX (reg_base_value, ui) = new_reg_base_value[ui];
+ VEC_replace (rtx, reg_base_value, ui, new_reg_base_value[ui]);
changed = 1;
}
}
if (reg_known_value[i] == 0)
reg_known_value[i] = regno_reg_rtx[i + FIRST_PSEUDO_REGISTER];
- /* Simplify the reg_base_value array so that no register refers to
- another register, except to special registers indirectly through
- ADDRESS expressions.
-
- In theory this loop can take as long as O(registers^2), but unless
- there are very long dependency chains it will run in close to linear
- time.
-
- This loop may not be needed any longer now that the main loop does
- a better job at propagating alias information. */
- pass = 0;
- do
- {
- changed = 0;
- pass++;
- for (ui = 0; ui < maxreg; ui++)
- {
- rtx base = VARRAY_RTX (reg_base_value, ui);
- if (base && REG_P (base))
- {
- unsigned int base_regno = REGNO (base);
- if (base_regno == ui) /* register set from itself */
- VARRAY_RTX (reg_base_value, ui) = 0;
- else
- VARRAY_RTX (reg_base_value, ui)
- = VARRAY_RTX (reg_base_value, base_regno);
- changed = 1;
- }
- }
- }
- while (changed && pass < MAX_ALIAS_LOOP_PASSES);
-
/* Clean up. */
free (new_reg_base_value);
new_reg_base_value = 0;
reg_known_value_size = 0;
free (reg_known_equiv_p);
reg_known_equiv_p = 0;
- if (alias_invariant)
- {
- ggc_free (alias_invariant);
- alias_invariant = 0;
- alias_invariant_size = 0;
- }
-}
-\f
-/* Do control and data flow analysis; write some of the results to the
- dump file. */
-static void
-rest_of_handle_cfg (void)
-{
- if (dump_file)
- dump_flow_info (dump_file);
- if (optimize)
- cleanup_cfg (CLEANUP_EXPENSIVE
- | (flag_thread_jumps ? CLEANUP_THREADING : 0));
}
-struct tree_opt_pass pass_cfg =
-{
- "cfg", /* name */
- NULL, /* gate */
- rest_of_handle_cfg, /* execute */
- NULL, /* sub */
- NULL, /* next */
- 0, /* static_pass_number */
- TV_FLOW, /* tv_id */
- 0, /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- TODO_dump_func, /* todo_flags_finish */
- 'f' /* letter */
-};
-
-
#include "gt-alias.h"
OSDN Git Service
