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));
/* Set up all info needed to perform alias analysis on memory references. */
}
}
-/* 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. */
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
+ if ((regno >= FIRST_PSEUDO_REGISTER || fixed_regs[regno])
&& regno < reg_base_value_size
&& reg_base_value[regno])
return reg_base_value[regno];
{
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;
}
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)
}
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:
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 deterimine 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;
- rtlx = DECL_RTL (MEM_DECL (x));
- rtly = DECL_RTL (MEM_DECL (y));
+ /* 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;
+ }
+ 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;
+ }
+
+ if (! DECL_P (exprx) || ! DECL_P (expry))
+ return 0;
+
+ rtlx = DECL_RTL (exprx);
+ rtly = DECL_RTL (expry);
- /* If either RTL is a REG, they can't overlap unless they are the same
- because we never reuse that part of the stack frame used for locals for
- spilled pseudos. */
- if ((REG_P (rtlx) || REG_P (rtly)) && ! rtx_equal_p (rtlx, rtly))
+ /* 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
+ of the stack frame used for locals for spilled pseudos. */
+ if ((GET_CODE (rtlx) != MEM || GET_CODE (rtly) != MEM)
+ && ! rtx_equal_p (rtlx, rtly))
return 1;
/* Get the base and offsets of both decls. If either is a register, we
know both are and are the same, so use that as the base. The only
we can avoid overlap is if we can deduce that they are nonoverlapping
pieces of that decl, which is very rare. */
- basex = REG_P (rtlx) ? rtlx : XEXP (rtlx, 0);
+ basex = GET_CODE (rtlx) == MEM ? XEXP (rtlx, 0) : rtlx;
if (GET_CODE (basex) == PLUS && GET_CODE (XEXP (basex, 1)) == CONST_INT)
offsetx = INTVAL (XEXP (basex, 1)), basex = XEXP (basex, 0);
- basey = REG_P (rtly) ? rtly : XEXP (rtly, 0);
+ basey = GET_CODE (rtly) == MEM ? XEXP (rtly, 0) : rtly;
if (GET_CODE (basey) == PLUS && GET_CODE (XEXP (basey, 1)) == CONST_INT)
offsety = INTVAL (XEXP (basey, 1)), basey = XEXP (basey, 0);
if (! rtx_equal_p (basex, basey))
return ((CONSTANT_P (basex) && CONSTANT_P (basey))
|| (CONSTANT_P (basex) && REG_P (basey)
- && REGNO (basey) <= LAST_VIRTUAL_REGISTER)
+ && REGNO_PTR_FRAME_P (REGNO (basey)))
|| (CONSTANT_P (basey) && REG_P (basex)
- && REGNO (basex) <= LAST_VIRTUAL_REGISTER));
+ && REGNO_PTR_FRAME_P (REGNO (basex))));
- sizex = (REG_P (rtlx) ? 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 = (REG_P (rtly) ? 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 or size 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 (MEM_SIZE (x))
+ /* If we have an offset for either memref, it can update the values computed
+ above. */
+ 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 if the offset isn't known because we must view this
+ memref as being anywhere inside the DECL's MEM. */
+ if (MEM_SIZE (x) && moffsetx)
sizex = INTVAL (MEM_SIZE (x));
- if (MEM_SIZE (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 (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;
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;
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;
{
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 non-zero 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 non-zero 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;
}
+/* Returns non-zero 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 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)
|| DECL_IS_PURE (current_function_decl)
|| TREE_THIS_VOLATILE (current_function_decl)
- || TYPE_MODE (TREE_TYPE (current_function_decl)) == VOIDmode)
+ || TYPE_MODE (TREE_TYPE (current_function_decl)) == VOIDmode
+ || current_function_has_nonlocal_goto)
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;
- break;
- }
+ {
+ if (! INSN_P (insn))
+ continue;
- end_alias_analysis ();
+ 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)
+
+ if (insn)
+ ;
+ else if (nonlocal_memory_referenced)
+ DECL_IS_PURE (current_function_decl) = 1;
+ else
TREE_READONLY (current_function_decl) = 1;
}
-
+\f
static HARD_REG_SET argument_registers;
OSDN Git Service
