/* Alias analysis for GNU C
- Copyright (C) 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+ Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003
+ Free Software Foundation, Inc.
Contributed by John Carr (jfc@mit.edu).
This file is part of GCC.
#include "config.h"
#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
#include "rtl.h"
#include "tree.h"
#include "tm_p.h"
#include "splay-tree.h"
#include "ggc.h"
#include "langhooks.h"
+#include "timevar.h"
+#include "target.h"
+#include "cgraph.h"
/* The alias sets assigned to MEMs assist the back-end in determining
which MEMs can alias which other MEMs. In general, two MEMs in
To see whether two alias sets can point to the same memory, we must
see if either alias set is a subset of the other. We need not trace
- past immediate descendents, however, since we propagate all
+ past immediate descendants, however, since we propagate all
grandchildren up one level.
Alias set zero is implicitly a superset of all other alias sets.
HOST_WIDE_INT alias_set;
/* The children of the alias set. These are not just the immediate
- children, but, in fact, all descendents. So, if we have:
+ children, but, in fact, all descendants. So, if we have:
- struct T { struct S s; float f; }
+ struct T { struct S s; float f; }
continuing our example above, the children here will be all of
`int', `double', `float', and `struct S'. */
static int memrefs_conflict_p PARAMS ((int, rtx, int, rtx,
HOST_WIDE_INT));
static void record_set PARAMS ((rtx, rtx, void *));
-static rtx find_base_term PARAMS ((rtx));
static int base_alias_check PARAMS ((rtx, rtx, enum machine_mode,
enum machine_mode));
-static int handled_component_p PARAMS ((tree));
static rtx find_base_value PARAMS ((rtx));
static int mems_in_disjoint_alias_sets_p PARAMS ((rtx, rtx));
static int insert_subset_children PARAMS ((splay_tree_node, void*));
static rtx fixed_scalar_and_varying_struct_p PARAMS ((rtx, rtx, rtx, rtx,
int (*) (rtx, int)));
static int aliases_everything_p PARAMS ((rtx));
+static bool nonoverlapping_component_refs_p PARAMS ((tree, tree));
+static tree decl_for_component_ref PARAMS ((tree));
+static rtx adjust_offset_for_component_ref PARAMS ((tree, rtx));
static int nonoverlapping_memrefs_p PARAMS ((rtx, rtx));
static int write_dependence_p PARAMS ((rtx, rtx, int));
+
+static int nonlocal_mentioned_p_1 PARAMS ((rtx *, void *));
static int nonlocal_mentioned_p PARAMS ((rtx));
+static int nonlocal_referenced_p_1 PARAMS ((rtx *, void *));
+static int nonlocal_referenced_p PARAMS ((rtx));
+static int nonlocal_set_p_1 PARAMS ((rtx *, void *));
+static int nonlocal_set_p PARAMS ((rtx));
+static void memory_modified_1 PARAMS ((rtx, rtx, void *));
/* Set up all info needed to perform alias analysis on memory references. */
/* Cap the number of passes we make over the insns propagating alias
information through set chains. 10 is a completely arbitrary choice. */
#define MAX_ALIAS_LOOP_PASSES 10
-
+
/* reg_base_value[N] gives an address to which register N is related.
If all sets after the first add or subtract to the current value
or otherwise modify it so it does not point to a different top level
A base address can be an ADDRESS, SYMBOL_REF, or LABEL_REF. ADDRESS
expressions represent certain special values: function arguments and
- the stack, frame, and argument pointers.
+ the stack, frame, and argument pointers.
The contents of an ADDRESS is not normally used, the mode of the
ADDRESS determines whether the ADDRESS is a function argument or some
current function performs nonlocal memory memory references for the
purposes of marking the function as a constant function. */
-static rtx *reg_base_value;
+static GTY((length ("reg_base_value_size"))) rtx *reg_base_value;
static rtx *new_reg_base_value;
static unsigned int reg_base_value_size; /* size of reg_base_value array */
+/* 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) \
(REGNO (X) < reg_base_value_size \
? reg_base_value[REGNO (X)] : 0)
/* True when scanning insns from the start of the rtl to the
NOTE_INSN_FUNCTION_BEG note. */
-static int copying_arguments;
+static bool copying_arguments;
/* The splay-tree used to store the various alias set entries. */
static splay_tree alias_sets;
/* Returns nonzero if the alias sets for MEM1 and MEM2 are such that
the two MEMs cannot alias each other. */
-static int
+static int
mems_in_disjoint_alias_sets_p (mem1, mem2)
rtx mem1;
rtx mem2;
{
-#ifdef ENABLE_CHECKING
+#ifdef ENABLE_CHECKING
/* Perform a basic sanity check. Namely, that there are no alias sets
if we're not using strict aliasing. This helps to catch bugs
whereby someone uses PUT_CODE, but doesn't clear MEM_ALIAS_SET, or
then they may not conflict. */
if ((t1 != 0 && readonly_fields_p (t1))
|| (t2 != 0 && readonly_fields_p (t2))
- || (t1 != 0 && TYPE_READONLY (t1))
- || (t2 != 0 && TYPE_READONLY (t2)))
+ || (t1 != 0 && lang_hooks.honor_readonly && TYPE_READONLY (t1))
+ || (t2 != 0 && lang_hooks.honor_readonly && TYPE_READONLY (t2)))
return 0;
/* If they are the same type, they must conflict. */
}
}
-/* Return 1 if T is an expression that get_inner_reference handles. */
-
-static int
-handled_component_p (t)
- tree t;
-{
- switch (TREE_CODE (t))
- {
- case BIT_FIELD_REF:
- case COMPONENT_REF:
- case ARRAY_REF:
- case ARRAY_RANGE_REF:
- case NON_LVALUE_EXPR:
- return 1;
-
- case NOP_EXPR:
- case CONVERT_EXPR:
- return (TYPE_MODE (TREE_TYPE (t))
- == TYPE_MODE (TREE_TYPE (TREE_OPERAND (t, 0))));
-
- default:
- return 0;
- }
-}
-
/* Return 1 if all the nested component references handled by
get_inner_reference in T are such that we can address the object in T. */
else
{
DECL_POINTER_ALIAS_SET (decl) = new_alias_set ();
- record_alias_subset (pointed_to_alias_set,
- DECL_POINTER_ALIAS_SET (decl));
+ record_alias_subset (pointed_to_alias_set,
+ DECL_POINTER_ALIAS_SET (decl));
}
}
and references to functions, but that's different.) */
else if (TREE_CODE (t) == FUNCTION_TYPE)
set = 0;
+
+ /* Unless the language specifies otherwise, let vector types alias
+ their components. This avoids some nasty type punning issues in
+ normal usage. And indeed lets vectors be treated more like an
+ array slice. */
+ else if (TREE_CODE (t) == VECTOR_TYPE)
+ set = get_alias_set (TREE_TYPE (t));
+
else
/* Otherwise make a new alias set for this type. */
set = new_alias_set ();
not vice versa. For example, in C, a store to an `int' can alias a
structure containing an `int', but not vice versa. Here, the
structure would be the SUPERSET and `int' the SUBSET. This
- function should be called only once per SUPERSET/SUBSET pair.
+ function should be called only once per SUPERSET/SUBSET pair.
It is illegal for SUPERSET to be zero; everything is implicitly a
subset of alias set zero. */
abort ();
superset_entry = get_alias_set_entry (superset);
- if (superset_entry == 0)
+ if (superset_entry == 0)
{
/* Create an entry for the SUPERSET, so that we have a place to
attach the SUBSET. */
superset_entry
= (alias_set_entry) xmalloc (sizeof (struct alias_set_entry));
superset_entry->alias_set = superset;
- superset_entry->children
+ superset_entry->children
= splay_tree_new (splay_tree_compare_ints, 0, 0);
superset_entry->has_zero_child = 0;
splay_tree_insert (alias_sets, (splay_tree_key) superset,
subset_entry = get_alias_set_entry (subset);
/* If there is an entry for the subset, enter all of its children
(if they are not already present) as children of the SUPERSET. */
- if (subset_entry)
+ if (subset_entry)
{
if (subset_entry->has_zero_child)
superset_entry->has_zero_child = 1;
}
/* Enter the SUBSET itself as a child of the SUPERSET. */
- splay_tree_insert (superset_entry->children,
+ splay_tree_insert (superset_entry->children,
(splay_tree_key) subset, 0);
}
}
case RECORD_TYPE:
case UNION_TYPE:
case QUAL_UNION_TYPE:
+ /* Recursively record aliases for the base classes, if there are any */
+ if (TYPE_BINFO (type) != NULL && TYPE_BINFO_BASETYPES (type) != NULL)
+ {
+ int i;
+ for (i = 0; i < TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type)); i++)
+ {
+ tree binfo = TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type), i);
+ record_alias_subset (superset,
+ get_alias_set (BINFO_TYPE (binfo)));
+ }
+ }
for (field = TYPE_FIELDS (type); field != 0; field = TREE_CHAIN (field))
if (TREE_CODE (field) == FIELD_DECL && ! DECL_NONADDRESSABLE_P (field))
record_alias_subset (superset, get_alias_set (TREE_TYPE (field)));
rtx src;
{
unsigned int regno;
+
switch (GET_CODE (src))
{
case SYMBOL_REF:
return new_reg_base_value[regno];
/* If a pseudo has a known base value, return it. Do not do this
- for hard regs since it can result in a circular dependency
- chain for registers which have values at function entry.
+ for non-fixed hard regs since it can result in a circular
+ dependency chain for registers which have values at function entry.
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
- && regno < reg_base_value_size
- && reg_base_value[regno])
- return reg_base_value[regno];
+ if ((regno >= FIRST_PSEUDO_REGISTER || fixed_regs[regno])
+ && regno < reg_base_value_size)
+ {
+ /* 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)
+ return new_reg_base_value[regno];
+
+ if (reg_base_value[regno])
+ return reg_base_value[regno];
+ }
return src;
{
rtx temp, src_0 = XEXP (src, 0), src_1 = XEXP (src, 1);
+ /* If either operand is a REG that is a known pointer, then it
+ is the base. */
+ if (REG_P (src_0) && REG_POINTER (src_0))
+ return find_base_value (src_0);
+ if (REG_P (src_1) && REG_POINTER (src_1))
+ return find_base_value (src_1);
+
/* If either operand is a REG, then see if we already have
a known value for it. */
- if (GET_CODE (src_0) == REG)
+ if (REG_P (src_0))
{
temp = find_base_value (src_0);
if (temp != 0)
src_0 = temp;
}
- if (GET_CODE (src_1) == REG)
+ if (REG_P (src_1))
{
temp = find_base_value (src_1);
if (temp!= 0)
src_1 = temp;
}
+ /* If either base is named object or a special address
+ (like an argument or stack reference), then use it for the
+ base term. */
+ if (src_0 != 0
+ && (GET_CODE (src_0) == SYMBOL_REF
+ || GET_CODE (src_0) == LABEL_REF
+ || (GET_CODE (src_0) == ADDRESS
+ && GET_MODE (src_0) != VOIDmode)))
+ return src_0;
+
+ if (src_1 != 0
+ && (GET_CODE (src_1) == SYMBOL_REF
+ || GET_CODE (src_1) == LABEL_REF
+ || (GET_CODE (src_1) == ADDRESS
+ && GET_MODE (src_1) != VOIDmode)))
+ return src_1;
+
/* Guess which operand is the base address:
If either operand is a symbol, then it is the base. If
either operand is a CONST_INT, then the other is the base. */
else if (GET_CODE (src_0) == CONST_INT || CONSTANT_P (src_1))
return find_base_value (src_1);
- /* This might not be necessary anymore:
- If either operand is a REG that is a known pointer, then it
- is the base. */
- else if (GET_CODE (src_0) == REG && REG_POINTER (src_0))
- return find_base_value (src_0);
- else if (GET_CODE (src_1) == REG && REG_POINTER (src_1))
- return find_base_value (src_1);
-
return 0;
}
if (GET_MODE_SIZE (GET_MODE (src)) < GET_MODE_SIZE (Pmode))
break;
/* Fall through. */
- case ZERO_EXTEND:
- case SIGN_EXTEND: /* used for NT/Alpha pointers */
case HIGH:
+ case PRE_INC:
+ case PRE_DEC:
+ case POST_INC:
+ case POST_DEC:
+ case PRE_MODIFY:
+ case POST_MODIFY:
return find_base_value (XEXP (src, 0));
+ case ZERO_EXTEND:
+ case SIGN_EXTEND: /* used for NT/Alpha pointers */
+ {
+ rtx temp = find_base_value (XEXP (src, 0));
+
+#ifdef POINTERS_EXTEND_UNSIGNED
+ if (temp != 0 && CONSTANT_P (temp) && GET_MODE (temp) != Pmode)
+ temp = convert_memory_address (Pmode, temp);
+#endif
+
+ return temp;
+ }
+
default:
break;
}
{
unsigned regno;
rtx src;
+ int n;
if (GET_CODE (dest) != REG)
return;
if (regno >= reg_base_value_size)
abort ();
+ /* If this spans multiple hard registers, then we must indicate that every
+ register has an unusable value. */
+ if (regno < FIRST_PSEUDO_REGISTER)
+ n = HARD_REGNO_NREGS (regno, GET_MODE (dest));
+ else
+ n = 1;
+ if (n != 1)
+ {
+ while (--n >= 0)
+ {
+ reg_seen[regno + n] = 1;
+ new_reg_base_value[regno + n] = 0;
+ }
+ return;
+ }
+
if (set)
{
/* A CLOBBER wipes out any old value but does not prevent a previously
}
/* Return 1 if X and Y are identical-looking rtx's.
+ Expect that X and Y has been already canonicalized.
We use the data in reg_known_value above to see if two registers with
different numbers are, in fact, equivalent. */
if (x == 0 || y == 0)
return 0;
- x = canon_rtx (x);
- y = canon_rtx (y);
-
if (x == y)
return 1;
case LABEL_REF:
return XEXP (x, 0) == XEXP (y, 0);
-
+
case SYMBOL_REF:
return XSTR (x, 0) == XSTR (y, 0);
case ADDRESSOF:
return (XINT (x, 1) == XINT (y, 1)
- && rtx_equal_for_memref_p (XEXP (x, 0), XEXP (y, 0)));
+ && rtx_equal_for_memref_p (XEXP (x, 0),
+ XEXP (y, 0)));
default:
break;
}
- /* For commutative operations, the RTX match if the operand match in any
- order. Also handle the simple binary and unary cases without a loop. */
- if (code == EQ || code == NE || GET_RTX_CLASS (code) == 'c')
+ /* canon_rtx knows how to handle plus. No need to canonicalize. */
+ if (code == PLUS)
return ((rtx_equal_for_memref_p (XEXP (x, 0), XEXP (y, 0))
&& rtx_equal_for_memref_p (XEXP (x, 1), XEXP (y, 1)))
|| (rtx_equal_for_memref_p (XEXP (x, 0), XEXP (y, 1))
&& rtx_equal_for_memref_p (XEXP (x, 1), XEXP (y, 0))));
+ /* For commutative operations, the RTX match if the operand match in any
+ order. Also handle the simple binary and unary cases without a loop. */
+ if (code == EQ || code == NE || GET_RTX_CLASS (code) == 'c')
+ {
+ rtx xop0 = canon_rtx (XEXP (x, 0));
+ rtx yop0 = canon_rtx (XEXP (y, 0));
+ rtx yop1 = canon_rtx (XEXP (y, 1));
+
+ return ((rtx_equal_for_memref_p (xop0, yop0)
+ && rtx_equal_for_memref_p (canon_rtx (XEXP (x, 1)), yop1))
+ || (rtx_equal_for_memref_p (xop0, yop1)
+ && rtx_equal_for_memref_p (canon_rtx (XEXP (x, 1)), yop0)));
+ }
else if (GET_RTX_CLASS (code) == '<' || GET_RTX_CLASS (code) == '2')
- return (rtx_equal_for_memref_p (XEXP (x, 0), XEXP (y, 0))
- && rtx_equal_for_memref_p (XEXP (x, 1), XEXP (y, 1)));
+ {
+ return (rtx_equal_for_memref_p (canon_rtx (XEXP (x, 0)),
+ canon_rtx (XEXP (y, 0)))
+ && rtx_equal_for_memref_p (canon_rtx (XEXP (x, 1)),
+ canon_rtx (XEXP (y, 1))));
+ }
else if (GET_RTX_CLASS (code) == '1')
- return rtx_equal_for_memref_p (XEXP (x, 0), XEXP (y, 0));
+ return rtx_equal_for_memref_p (canon_rtx (XEXP (x, 0)),
+ canon_rtx (XEXP (y, 0)));
/* Compare the elements. If any pair of corresponding elements
fail to match, return 0 for the whole things.
/* And the corresponding elements must match. */
for (j = 0; j < XVECLEN (x, i); j++)
- if (rtx_equal_for_memref_p (XVECEXP (x, i, j),
- XVECEXP (y, i, j)) == 0)
+ if (rtx_equal_for_memref_p (canon_rtx (XVECEXP (x, i, j)),
+ canon_rtx (XVECEXP (y, i, j))) == 0)
return 0;
break;
case 'e':
- if (rtx_equal_for_memref_p (XEXP (x, i), XEXP (y, i)) == 0)
+ if (rtx_equal_for_memref_p (canon_rtx (XEXP (x, i)),
+ canon_rtx (XEXP (y, i))) == 0)
return 0;
break;
return 0;
}
-static rtx
+rtx
find_base_term (x)
rtx x;
{
case REG:
return REG_BASE_VALUE (x);
- case ZERO_EXTEND:
- case SIGN_EXTEND: /* Used for Alpha/NT pointers */
+ case TRUNCATE:
+ if (GET_MODE_SIZE (GET_MODE (x)) < GET_MODE_SIZE (Pmode))
+ return 0;
+ /* Fall through. */
case HIGH:
case PRE_INC:
case PRE_DEC:
case POST_INC:
case POST_DEC:
+ case PRE_MODIFY:
+ case POST_MODIFY:
return find_base_term (XEXP (x, 0));
+ case ZERO_EXTEND:
+ case SIGN_EXTEND: /* Used for Alpha/NT pointers */
+ {
+ rtx temp = find_base_term (XEXP (x, 0));
+
+#ifdef POINTERS_EXTEND_UNSIGNED
+ if (temp != 0 && CONSTANT_P (temp) && GET_MODE (temp) != Pmode)
+ temp = convert_memory_address (Pmode, temp);
+#endif
+
+ return temp;
+ }
+
case VALUE:
val = CSELIB_VAL_PTR (x);
for (l = val->locs; l; l = l->next)
tests can certainly be added. For example, if one of the operands
is a shift or multiply, then it must be the index register and the
other operand is the base register. */
-
+
if (tmp1 == pic_offset_table_rtx && CONSTANT_P (tmp2))
return find_base_term (tmp2);
}
case AND:
- if (GET_CODE (XEXP (x, 0)) == REG && GET_CODE (XEXP (x, 1)) == CONST_INT)
- return REG_BASE_VALUE (XEXP (x, 0));
+ if (GET_CODE (XEXP (x, 1)) == CONST_INT && INTVAL (XEXP (x, 1)) != 0)
+ return find_base_term (XEXP (x, 0));
return 0;
case SYMBOL_REF:
if (rtx_equal_p (x_base, y_base))
return 1;
- /* The base addresses of the read and write are different expressions.
+ /* The base addresses of the read and write are different expressions.
If they are both symbols and they are not accessed via AND, there is
no conflict. We can bring knowledge of object alignment into play
here. For example, on alpha, "char a, b;" can alias one another,
int n_refs;
{
int offset = 0;
-
+
switch (GET_CODE (addr))
{
case PRE_INC:
default:
return addr;
}
-
+
if (offset)
- addr = gen_rtx_PLUS (GET_MODE (addr), XEXP (addr, 0), GEN_INT (offset));
+ addr = gen_rtx_PLUS (GET_MODE (addr), XEXP (addr, 0),
+ GEN_INT (offset));
else
addr = XEXP (addr, 0);
+ addr = canon_rtx (addr);
return addr;
}
C is nonzero, we are testing aliases between X and Y + C.
XSIZE is the size in bytes of the X reference,
similarly YSIZE is the size in bytes for Y.
+ Expect that canon_rtx has been already called for X and Y.
If XSIZE or YSIZE is zero, we do not know the amount of memory being
referenced (the reference was BLKmode), so make the most pessimistic
else if (GET_CODE (x) == LO_SUM)
x = XEXP (x, 1);
else
- x = canon_rtx (addr_side_effect_eval (x, xsize, 0));
+ x = addr_side_effect_eval (x, xsize, 0);
if (GET_CODE (y) == HIGH)
y = XEXP (y, 0);
else if (GET_CODE (y) == LO_SUM)
y = XEXP (y, 1);
else
- y = canon_rtx (addr_side_effect_eval (y, ysize, 0));
+ y = addr_side_effect_eval (y, ysize, 0);
if (rtx_equal_for_memref_p (x, y))
{
}
/* Treat an access through an AND (e.g. a subword access on an Alpha)
- as an access with indeterminate size. Assume that references
+ as an access with indeterminate size. Assume that references
besides AND are aligned, so if the size of the other reference is
at least as large as the alignment, assume no other overlap. */
if (GET_CODE (x) == AND && GET_CODE (XEXP (x, 1)) == CONST_INT)
{
if (GET_CODE (y) == AND || ysize < -INTVAL (XEXP (x, 1)))
xsize = -1;
- return memrefs_conflict_p (xsize, XEXP (x, 0), ysize, y, c);
+ return memrefs_conflict_p (xsize, canon_rtx (XEXP (x, 0)), ysize, y, c);
}
if (GET_CODE (y) == AND && GET_CODE (XEXP (y, 1)) == CONST_INT)
{
/* ??? If we are indexing far enough into the array/structure, we
- may yet be able to determine that we can not overlap. But we
+ may yet be able to determine that we can not overlap. But we
also need to that we are far enough from the end not to overlap
a following reference, so we do nothing with that for now. */
if (GET_CODE (x) == AND || xsize < -INTVAL (XEXP (y, 1)))
ysize = -1;
- return memrefs_conflict_p (xsize, x, ysize, XEXP (y, 0), c);
+ return memrefs_conflict_p (xsize, x, ysize, canon_rtx (XEXP (y, 0)), c);
}
if (GET_CODE (x) == ADDRESSOF)
If both memory references are volatile, then there must always be a
dependence between the two references, since their order can not be
changed. A volatile and non-volatile reference can be interchanged
- though.
+ though.
A MEM_IN_STRUCT reference at a non-AND varying address can never
conflict with a non-MEM_IN_STRUCT reference at a fixed address. We
to decide whether or not an address may vary; it should return
nonzero whenever variation is possible.
MEM1_ADDR and MEM2_ADDR are the addresses of MEM1 and MEM2. */
-
+
static rtx
fixed_scalar_and_varying_struct_p (mem1, mem2, mem1_addr, mem2_addr, varies_p)
rtx mem1, mem2;
rtx mem1_addr, mem2_addr;
int (*varies_p) PARAMS ((rtx, int));
-{
+{
if (! flag_strict_aliasing)
return NULL_RTX;
- if (MEM_SCALAR_P (mem1) && MEM_IN_STRUCT_P (mem2)
+ if (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_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. */
/* If the address is an AND, its very hard to know at what it is
actually pointing. */
return 1;
-
+
return 0;
}
-/* Return nonzero if we can deterimine the decls corresponding to memrefs
+/* Return true if we can determine that the fields referenced cannot
+ overlap for any pair of objects. */
+
+static bool
+nonoverlapping_component_refs_p (x, y)
+ tree x, y;
+{
+ tree fieldx, fieldy, typex, typey, orig_y;
+
+ do
+ {
+ /* The comparison has to be done at a common type, since we don't
+ know how the inheritance hierarchy works. */
+ orig_y = y;
+ do
+ {
+ fieldx = TREE_OPERAND (x, 1);
+ typex = DECL_FIELD_CONTEXT (fieldx);
+
+ y = orig_y;
+ do
+ {
+ fieldy = TREE_OPERAND (y, 1);
+ typey = DECL_FIELD_CONTEXT (fieldy);
+
+ if (typex == typey)
+ goto found;
+
+ y = TREE_OPERAND (y, 0);
+ }
+ while (y && TREE_CODE (y) == COMPONENT_REF);
+
+ x = TREE_OPERAND (x, 0);
+ }
+ while (x && TREE_CODE (x) == COMPONENT_REF);
+
+ /* Never found a common type. */
+ return false;
+
+ found:
+ /* If we're left with accessing different fields of a structure,
+ then no overlap. */
+ if (TREE_CODE (typex) == RECORD_TYPE
+ && fieldx != fieldy)
+ return true;
+
+ /* The comparison on the current field failed. If we're accessing
+ a very nested structure, look at the next outer level. */
+ x = TREE_OPERAND (x, 0);
+ y = TREE_OPERAND (y, 0);
+ }
+ while (x && y
+ && TREE_CODE (x) == COMPONENT_REF
+ && TREE_CODE (y) == COMPONENT_REF);
+
+ return false;
+}
+
+/* Look at the bottom of the COMPONENT_REF list for a DECL, and return it. */
+
+static tree
+decl_for_component_ref (x)
+ tree x;
+{
+ do
+ {
+ x = TREE_OPERAND (x, 0);
+ }
+ while (x && TREE_CODE (x) == COMPONENT_REF);
+
+ return x && DECL_P (x) ? x : NULL_TREE;
+}
+
+/* Walk up the COMPONENT_REF list and adjust OFFSET to compensate for the
+ offset of the field reference. */
+
+static rtx
+adjust_offset_for_component_ref (x, offset)
+ tree x;
+ rtx offset;
+{
+ HOST_WIDE_INT ioffset;
+
+ if (! offset)
+ return NULL_RTX;
+
+ ioffset = INTVAL (offset);
+ do
+ {
+ tree field = TREE_OPERAND (x, 1);
+
+ if (! host_integerp (DECL_FIELD_OFFSET (field), 1))
+ return NULL_RTX;
+ ioffset += (tree_low_cst (DECL_FIELD_OFFSET (field), 1)
+ + (tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
+ / BITS_PER_UNIT));
+
+ x = TREE_OPERAND (x, 0);
+ }
+ while (x && TREE_CODE (x) == COMPONENT_REF);
+
+ return GEN_INT (ioffset);
+}
+
+/* Return nonzero if we can determine the exprs corresponding to memrefs
X and Y and they do not overlap. */
static int
nonoverlapping_memrefs_p (x, y)
rtx x, y;
{
+ tree exprx = MEM_EXPR (x), expry = MEM_EXPR (y);
rtx rtlx, rtly;
rtx basex, basey;
+ rtx moffsetx, moffsety;
HOST_WIDE_INT offsetx = 0, offsety = 0, sizex, sizey, tem;
- /* Unless both have decls, we can't tell anything. */
- if (MEM_DECL (x) == 0 || MEM_DECL (y) == 0)
+ /* 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 t = decl_for_component_ref (exprx);
+ if (! t)
+ return 0;
+ moffsetx = adjust_offset_for_component_ref (exprx, moffsetx);
+ exprx = t;
+ }
+ else if (TREE_CODE (exprx) == INDIRECT_REF)
+ {
+ exprx = TREE_OPERAND (exprx, 0);
+ if (flag_argument_noalias < 2
+ || TREE_CODE (exprx) != PARM_DECL)
+ return 0;
+ }
+
+ moffsety = MEM_OFFSET (y);
+ if (TREE_CODE (expry) == COMPONENT_REF)
+ {
+ tree t = decl_for_component_ref (expry);
+ if (! t)
+ return 0;
+ moffsety = adjust_offset_for_component_ref (expry, moffsety);
+ expry = t;
+ }
+ else if (TREE_CODE (expry) == INDIRECT_REF)
+ {
+ expry = TREE_OPERAND (expry, 0);
+ if (flag_argument_noalias < 2
+ || TREE_CODE (expry) != PARM_DECL)
+ return 0;
+ }
+
+ if (! DECL_P (exprx) || ! DECL_P (expry))
return 0;
- rtlx = DECL_RTL (MEM_DECL (x));
- rtly = DECL_RTL (MEM_DECL (y));
+ rtlx = DECL_RTL (exprx);
+ rtly = DECL_RTL (expry);
/* If either RTL is not a MEM, it must be a REG or CONCAT, meaning they
can't overlap unless they are the same because we never reuse that part
offsety = INTVAL (XEXP (basey, 1)), basey = XEXP (basey, 0);
/* If the bases are different, we know they do not overlap if both
- are constants or if one is a constant and the other a pointer into the
+ are constants or if one is a constant and the other a pointer into the
stack frame. Otherwise a different base means we can't tell if they
overlap or not. */
if (! rtx_equal_p (basex, basey))
- return ((CONSTANT_P (basex) && CONSTANT_P (basey))
- || (CONSTANT_P (basex) && REG_P (basey)
- && REGNO_PTR_FRAME_P (REGNO (basey)))
- || (CONSTANT_P (basey) && REG_P (basex)
- && REGNO_PTR_FRAME_P (REGNO (basex))));
+ return ((CONSTANT_P (basex) && CONSTANT_P (basey))
+ || (CONSTANT_P (basex) && REG_P (basey)
+ && REGNO_PTR_FRAME_P (REGNO (basey)))
+ || (CONSTANT_P (basey) && REG_P (basex)
+ && REGNO_PTR_FRAME_P (REGNO (basex))));
- sizex = (GET_CODE (rtlx) != MEM ? GET_MODE_SIZE (GET_MODE (rtlx))
+ sizex = (GET_CODE (rtlx) != MEM ? (int) GET_MODE_SIZE (GET_MODE (rtlx))
: MEM_SIZE (rtlx) ? INTVAL (MEM_SIZE (rtlx))
: -1);
- sizey = (GET_CODE (rtly) != MEM ? GET_MODE_SIZE (GET_MODE (rtly))
+ sizey = (GET_CODE (rtly) != MEM ? (int) GET_MODE_SIZE (GET_MODE (rtly))
: MEM_SIZE (rtly) ? INTVAL (MEM_SIZE (rtly)) :
-1);
/* If we have an offset for either memref, it can update the values computed
above. */
- if (MEM_OFFSET (x))
- offsetx += INTVAL (MEM_OFFSET (x)), sizex -= INTVAL (MEM_OFFSET (x));
- if (MEM_OFFSET (y))
- offsety += INTVAL (MEM_OFFSET (y)), sizey -= INTVAL (MEM_OFFSET (y));
+ if (moffsetx)
+ offsetx += INTVAL (moffsetx), sizex -= INTVAL (moffsetx);
+ if (moffsety)
+ offsety += INTVAL (moffsety), sizey -= INTVAL (moffsety);
/* If a memref has both a size and an offset, we can use the smaller size.
- We can't do this is the offset isn't know because we must view this
+ We can't do this if the offset isn't known because we must view this
memref as being anywhere inside the DECL's MEM. */
- if (MEM_SIZE (x) && MEM_OFFSET (x))
+ if (MEM_SIZE (x) && moffsetx)
sizex = INTVAL (MEM_SIZE (x));
- if (MEM_SIZE (y) && MEM_OFFSET (y))
+ if (MEM_SIZE (y) && moffsety)
sizey = INTVAL (MEM_SIZE (y));
/* Put the values of the memref with the lower offset in X's values. */
/* If we don't know the size of the lower-offset value, we can't tell
if they conflict. Otherwise, we do the test. */
- return sizex >= 0 && offsety > offsetx + sizex;
+ return sizex >= 0 && offsety >= offsetx + sizex;
}
/* True dependence: X is read after store in MEM takes place. */
if (MEM_VOLATILE_P (x) && MEM_VOLATILE_P (mem))
return 1;
+ /* (mem:BLK (scratch)) is a special mechanism to conflict with everything.
+ This is used in epilogue deallocation functions. */
+ 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 (DIFFERENT_ALIAS_SETS_P (x, mem))
return 0;
}
/* Canonical true dependence: X is read after store in MEM takes place.
- Variant of true_dependence which assumes MEM has already been
- canonicalized (hence we no longer do that here).
- The mem_addr argument has been added, since true_dependence computed
+ Variant of true_dependence which assumes MEM has already been
+ canonicalized (hence we no longer do that here).
+ The mem_addr argument has been added, since true_dependence computed
this value prior to canonicalizing. */
int
if (MEM_VOLATILE_P (x) && MEM_VOLATILE_P (mem))
return 1;
+ /* (mem:BLK (scratch)) is a special mechanism to conflict with everything.
+ This is used in epilogue deallocation functions. */
+ 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 (DIFFERENT_ALIAS_SETS_P (x, mem))
return 0;
varies);
}
-/* Returns non-zero if a write to X might alias a previous read from
- (or, if WRITEP is non-zero, a write to) MEM. */
+/* Returns nonzero if a write to X might alias a previous read from
+ (or, if WRITEP is nonzero, a write to) MEM. */
static int
write_dependence_p (mem, x, writep)
if (MEM_VOLATILE_P (x) && MEM_VOLATILE_P (mem))
return 1;
+ /* (mem:BLK (scratch)) is a special mechanism to conflict with everything.
+ This is used in epilogue deallocation functions. */
+ 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 (DIFFERENT_ALIAS_SETS_P (x, mem))
return 0;
SIZE_FOR_MODE (x), x_addr, 0))
return 0;
- fixed_scalar
+ fixed_scalar
= fixed_scalar_and_varying_struct_p (mem, x, mem_addr, x_addr,
rtx_addr_varies_p);
{
return write_dependence_p (mem, x, /*writep=*/1);
}
-
-/* Returns non-zero if X mentions something which is not
- local to the function and is not constant. */
+\f
+/* A subroutine of nonlocal_mentioned_p, returns 1 if *LOC mentions
+ something which is not local to the function and is not constant. */
static int
-nonlocal_mentioned_p (x)
- rtx x;
+nonlocal_mentioned_p_1 (loc, data)
+ rtx *loc;
+ void *data ATTRIBUTE_UNUSED;
{
+ rtx x = *loc;
rtx base;
- RTX_CODE code;
int regno;
- code = GET_CODE (x);
-
- if (GET_RTX_CLASS (code) == 'i')
- {
- /* Constant functions can be constant if they don't use
- scratch memory used to mark function w/o side effects. */
- if (code == CALL_INSN && CONST_OR_PURE_CALL_P (x))
- {
- x = CALL_INSN_FUNCTION_USAGE (x);
- if (x == 0)
- return 0;
- }
- else
- x = PATTERN (x);
- code = GET_CODE (x);
- }
+ if (! x)
+ return 0;
- switch (code)
+ switch (GET_CODE (x))
{
case SUBREG:
if (GET_CODE (SUBREG_REG (x)) == REG)
case CC0:
case CONST_INT:
case CONST_DOUBLE:
+ case CONST_VECTOR:
case CONST:
case LABEL_REF:
return 0;
break;
}
- /* Recursively scan the operands of this expression. */
+ return 0;
+}
- {
- const char *fmt = GET_RTX_FORMAT (code);
- int i;
-
- for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
- {
- if (fmt[i] == 'e' && XEXP (x, i))
- {
- if (nonlocal_mentioned_p (XEXP (x, i)))
- return 1;
- }
- else if (fmt[i] == 'E')
- {
- int j;
- for (j = 0; j < XVECLEN (x, i); j++)
- if (nonlocal_mentioned_p (XVECEXP (x, i, j)))
- return 1;
- }
- }
- }
+/* Returns nonzero if X might mention something which is not
+ local to the function and is not constant. */
+
+static int
+nonlocal_mentioned_p (x)
+ rtx x;
+{
+ if (INSN_P (x))
+ {
+ if (GET_CODE (x) == CALL_INSN)
+ {
+ if (! CONST_OR_PURE_CALL_P (x))
+ return 1;
+ x = CALL_INSN_FUNCTION_USAGE (x);
+ if (x == 0)
+ return 0;
+ }
+ else
+ x = PATTERN (x);
+ }
+
+ return for_each_rtx (&x, nonlocal_mentioned_p_1, NULL);
+}
+
+/* A subroutine of nonlocal_referenced_p, returns 1 if *LOC references
+ something which is not local to the function and is not constant. */
+
+static int
+nonlocal_referenced_p_1 (loc, data)
+ rtx *loc;
+ void *data ATTRIBUTE_UNUSED;
+{
+ rtx x = *loc;
+
+ if (! x)
+ return 0;
+
+ switch (GET_CODE (x))
+ {
+ case MEM:
+ case REG:
+ case SYMBOL_REF:
+ case SUBREG:
+ return nonlocal_mentioned_p (x);
+
+ case CALL:
+ /* Non-constant calls and recursion are not local. */
+ return 1;
+
+ case SET:
+ if (nonlocal_mentioned_p (SET_SRC (x)))
+ return 1;
+
+ if (GET_CODE (SET_DEST (x)) == MEM)
+ return nonlocal_mentioned_p (XEXP (SET_DEST (x), 0));
+
+ /* If the destination is anything other than a CC0, PC,
+ MEM, REG, or a SUBREG of a REG that occupies all of
+ the REG, then X references nonlocal memory if it is
+ mentioned in the destination. */
+ if (GET_CODE (SET_DEST (x)) != CC0
+ && GET_CODE (SET_DEST (x)) != PC
+ && GET_CODE (SET_DEST (x)) != REG
+ && ! (GET_CODE (SET_DEST (x)) == SUBREG
+ && GET_CODE (SUBREG_REG (SET_DEST (x))) == REG
+ && (((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (x))))
+ + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
+ == ((GET_MODE_SIZE (GET_MODE (SET_DEST (x)))
+ + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD))))
+ return nonlocal_mentioned_p (SET_DEST (x));
+ return 0;
+
+ case CLOBBER:
+ if (GET_CODE (XEXP (x, 0)) == MEM)
+ return nonlocal_mentioned_p (XEXP (XEXP (x, 0), 0));
+ return 0;
+
+ case USE:
+ return nonlocal_mentioned_p (XEXP (x, 0));
+
+ case ASM_INPUT:
+ case UNSPEC_VOLATILE:
+ return 1;
+
+ case ASM_OPERANDS:
+ if (MEM_VOLATILE_P (x))
+ return 1;
+
+ /* FALLTHROUGH */
+
+ default:
+ break;
+ }
+
+ return 0;
+}
+
+/* Returns nonzero if X might reference something which is not
+ local to the function and is not constant. */
+
+static int
+nonlocal_referenced_p (x)
+ rtx x;
+{
+ if (INSN_P (x))
+ {
+ if (GET_CODE (x) == CALL_INSN)
+ {
+ if (! CONST_OR_PURE_CALL_P (x))
+ return 1;
+ x = CALL_INSN_FUNCTION_USAGE (x);
+ if (x == 0)
+ return 0;
+ }
+ else
+ x = PATTERN (x);
+ }
+
+ return for_each_rtx (&x, nonlocal_referenced_p_1, NULL);
+}
+
+/* A subroutine of nonlocal_set_p, returns 1 if *LOC sets
+ something which is not local to the function and is not constant. */
+
+static int
+nonlocal_set_p_1 (loc, data)
+ rtx *loc;
+ void *data ATTRIBUTE_UNUSED;
+{
+ rtx x = *loc;
+
+ if (! x)
+ return 0;
+
+ switch (GET_CODE (x))
+ {
+ case CALL:
+ /* Non-constant calls and recursion are not local. */
+ return 1;
+
+ case PRE_INC:
+ case PRE_DEC:
+ case POST_INC:
+ case POST_DEC:
+ case PRE_MODIFY:
+ case POST_MODIFY:
+ return nonlocal_mentioned_p (XEXP (x, 0));
+
+ case SET:
+ if (nonlocal_mentioned_p (SET_DEST (x)))
+ return 1;
+ return nonlocal_set_p (SET_SRC (x));
+
+ case CLOBBER:
+ return nonlocal_mentioned_p (XEXP (x, 0));
+
+ case USE:
+ return 0;
+
+ case ASM_INPUT:
+ case UNSPEC_VOLATILE:
+ return 1;
+
+ case ASM_OPERANDS:
+ if (MEM_VOLATILE_P (x))
+ return 1;
+
+ /* FALLTHROUGH */
+
+ default:
+ break;
+ }
return 0;
}
-/* Mark the function if it is constant. */
+/* Returns nonzero if X might set something which is not
+ local to the function and is not constant. */
+
+static int
+nonlocal_set_p (x)
+ rtx x;
+{
+ if (INSN_P (x))
+ {
+ if (GET_CODE (x) == CALL_INSN)
+ {
+ if (! CONST_OR_PURE_CALL_P (x))
+ return 1;
+ x = CALL_INSN_FUNCTION_USAGE (x);
+ if (x == 0)
+ return 0;
+ }
+ else
+ x = PATTERN (x);
+ }
+
+ return for_each_rtx (&x, nonlocal_set_p_1, NULL);
+}
+
+/* Mark the function if it is pure or constant. */
void
mark_constant_function ()
{
rtx insn;
- int nonlocal_mentioned;
+ int nonlocal_memory_referenced;
- if (TREE_PUBLIC (current_function_decl)
- || TREE_READONLY (current_function_decl)
+ if (TREE_READONLY (current_function_decl)
|| DECL_IS_PURE (current_function_decl)
|| TREE_THIS_VOLATILE (current_function_decl)
- || TYPE_MODE (TREE_TYPE (current_function_decl)) == VOIDmode)
+ || current_function_has_nonlocal_goto
+ || !(*targetm.binds_local_p) (current_function_decl))
return;
/* A loop might not return which counts as a side effect. */
if (mark_dfs_back_edges ())
return;
- nonlocal_mentioned = 0;
+ nonlocal_memory_referenced = 0;
init_alias_analysis ();
- /* Determine if this is a constant function. */
+ /* Determine if this is a constant or pure function. */
for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
- if (INSN_P (insn) && nonlocal_mentioned_p (insn))
- {
- nonlocal_mentioned = 1;
+ {
+ if (! INSN_P (insn))
+ continue;
+
+ if (nonlocal_set_p (insn) || global_reg_mentioned_p (insn)
+ || volatile_refs_p (PATTERN (insn)))
break;
- }
+
+ if (! nonlocal_memory_referenced)
+ nonlocal_memory_referenced = nonlocal_referenced_p (insn);
+ }
end_alias_analysis ();
/* Mark the function. */
- if (! nonlocal_mentioned)
- TREE_READONLY (current_function_decl) = 1;
+ if (insn)
+ ;
+ else if (nonlocal_memory_referenced)
+ {
+ cgraph_rtl_info (current_function_decl)->pure_function = 1;
+ DECL_IS_PURE (current_function_decl) = 1;
+ }
+ else
+ {
+ cgraph_rtl_info (current_function_decl)->const_function = 1;
+ TREE_READONLY (current_function_decl) = 1;
+ }
}
-
-
-static HARD_REG_SET argument_registers;
+\f
void
init_alias_once ()
numbers, so translate if necessary due to register windows. */
if (FUNCTION_ARG_REGNO_P (OUTGOING_REGNO (i))
&& HARD_REGNO_MODE_OK (i, Pmode))
- SET_HARD_REG_BIT (argument_registers, i);
+ static_reg_base_value[i]
+ = gen_rtx_ADDRESS (VOIDmode, gen_rtx_REG (Pmode, i));
+
+ static_reg_base_value[STACK_POINTER_REGNUM]
+ = gen_rtx_ADDRESS (Pmode, stack_pointer_rtx);
+ static_reg_base_value[ARG_POINTER_REGNUM]
+ = gen_rtx_ADDRESS (Pmode, arg_pointer_rtx);
+ static_reg_base_value[FRAME_POINTER_REGNUM]
+ = gen_rtx_ADDRESS (Pmode, frame_pointer_rtx);
+#if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
+ static_reg_base_value[HARD_FRAME_POINTER_REGNUM]
+ = gen_rtx_ADDRESS (Pmode, hard_frame_pointer_rtx);
+#endif
alias_sets = splay_tree_new (splay_tree_compare_ints, 0, 0);
}
+/* Set MEMORY_MODIFIED when X modifies DATA (that is assumed
+ to be memory reference. */
+static bool memory_modified;
+static void
+memory_modified_1 (x, pat, data)
+ rtx x, pat ATTRIBUTE_UNUSED;
+ void *data;
+{
+ if (GET_CODE (x) == MEM)
+ {
+ if (anti_dependence (x, (rtx)data) || output_dependence (x, (rtx)data))
+ memory_modified = true;
+ }
+}
+
+
+/* Return true when INSN possibly modify memory contents of MEM
+ (ie address can be modified). */
+bool
+memory_modified_in_insn_p (mem, insn)
+ rtx mem, insn;
+{
+ if (!INSN_P (insn))
+ return false;
+ memory_modified = false;
+ note_stores (PATTERN (insn), memory_modified_1, mem);
+ return memory_modified;
+}
+
/* Initialize the aliasing machinery. Initialize the REG_KNOWN_VALUE
array. */
unsigned int ui;
rtx insn;
+ timevar_push (TV_ALIAS_ANALYSIS);
+
reg_known_value_size = maxreg;
- reg_known_value
+ reg_known_value
= (rtx *) xcalloc ((maxreg - FIRST_PSEUDO_REGISTER), sizeof (rtx))
- FIRST_PSEUDO_REGISTER;
- reg_known_equiv_p
+ reg_known_equiv_p
= (char*) xcalloc ((maxreg - FIRST_PSEUDO_REGISTER), sizeof (char))
- FIRST_PSEUDO_REGISTER;
optimization. Loop unrolling can create a large number of
registers. */
reg_base_value_size = maxreg * 2;
- reg_base_value = (rtx *) xcalloc (reg_base_value_size, sizeof (rtx));
- ggc_add_rtx_root (reg_base_value, reg_base_value_size);
+ reg_base_value = (rtx *) ggc_alloc_cleared (reg_base_value_size
+ * sizeof (rtx));
new_reg_base_value = (rtx *) xmalloc (reg_base_value_size * sizeof (rtx));
reg_seen = (char *) xmalloc (reg_base_value_size);
- if (! reload_completed && flag_unroll_loops)
+ if (! reload_completed && flag_old_unroll_loops)
{
/* ??? Why are we realloc'ing if we're just going to zero it? */
alias_invariant = (rtx *)xrealloc (alias_invariant,
/* We're at the start of the function each iteration through the
loop, so we're copying arguments. */
- copying_arguments = 1;
+ copying_arguments = true;
/* Wipe the potential alias information clean for this pass. */
memset ((char *) new_reg_base_value, 0, reg_base_value_size * sizeof (rtx));
The address expression is VOIDmode for an argument and
Pmode for other registers. */
- for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
- if (TEST_HARD_REG_BIT (argument_registers, i))
- new_reg_base_value[i] = gen_rtx_ADDRESS (VOIDmode,
- gen_rtx_REG (Pmode, i));
-
- new_reg_base_value[STACK_POINTER_REGNUM]
- = gen_rtx_ADDRESS (Pmode, stack_pointer_rtx);
- new_reg_base_value[ARG_POINTER_REGNUM]
- = gen_rtx_ADDRESS (Pmode, arg_pointer_rtx);
- new_reg_base_value[FRAME_POINTER_REGNUM]
- = gen_rtx_ADDRESS (Pmode, frame_pointer_rtx);
-#if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
- new_reg_base_value[HARD_FRAME_POINTER_REGNUM]
- = gen_rtx_ADDRESS (Pmode, hard_frame_pointer_rtx);
-#endif
+ memcpy (new_reg_base_value, static_reg_base_value,
+ FIRST_PSEUDO_REGISTER * sizeof (rtx));
/* Walk the insns adding values to the new_reg_base_value array. */
for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
}
else if (GET_CODE (insn) == NOTE
&& NOTE_LINE_NUMBER (insn) == NOTE_INSN_FUNCTION_BEG)
- copying_arguments = 0;
+ copying_arguments = false;
}
/* Now propagate values from new_reg_base_value to reg_base_value. */
new_reg_base_value = 0;
free (reg_seen);
reg_seen = 0;
+ timevar_pop (TV_ALIAS_ANALYSIS);
}
void
reg_known_value_size = 0;
free (reg_known_equiv_p + FIRST_PSEUDO_REGISTER);
reg_known_equiv_p = 0;
- if (reg_base_value)
- {
- ggc_del_root (reg_base_value);
- free (reg_base_value);
- reg_base_value = 0;
- }
+ reg_base_value = 0;
reg_base_value_size = 0;
if (alias_invariant)
{
alias_invariant = 0;
}
}
+
+#include "gt-alias.h"
OSDN Git Service
