alias.c: Fix formatting.
* alias.c: Fix formatting. * attribs.c: Likewise. * bb-reorder.c: Likewise. * bitmap.c: Likewise. * bitmap.h: Likewise. * builtins.c: Likewise. From-SVN: r53898
This commit is contained in:
Kazu Hirata
Kazu Hirata
parent
7aacf98920
commit
ca7fd9cd38
7 changed files with 167 additions and 158 deletions
|
|
@ -1,3 +1,12 @@
|
|||
2002-05-26 Kazu Hirata <kazu@cs.umass.edu>
|
||||
|
||||
* alias.c: Fix formatting.
|
||||
* attribs.c: Likewise.
|
||||
* bb-reorder.c: Likewise.
|
||||
* bitmap.c: Likewise.
|
||||
* bitmap.h: Likewise.
|
||||
* builtins.c: Likewise.
|
||||
|
||||
Sun May 26 14:00:44 CEST 2002 Jan Hubicka <jh@suse.cz>
|
||||
|
||||
* reload.c (find_valid_class): Accept new argument DEST,
|
||||
|
|
|
|||
116
gcc/alias.c
116
gcc/alias.c
|
|
@ -75,7 +75,7 @@ typedef struct alias_set_entry
|
|||
/* The children of the alias set. These are not just the immediate
|
||||
children, but, in fact, all descendents. 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'. */
|
||||
|
|
@ -131,7 +131,7 @@ static int nonlocal_set_p PARAMS ((rtx));
|
|||
/* 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
|
||||
|
|
@ -140,7 +140,7 @@ static int nonlocal_set_p PARAMS ((rtx));
|
|||
|
||||
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
|
||||
|
|
@ -215,12 +215,12 @@ get_alias_set_entry (alias_set)
|
|||
/* 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
|
||||
|
|
@ -514,8 +514,8 @@ get_alias_set (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));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -601,7 +601,7 @@ 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. */
|
||||
|
|
@ -623,14 +623,14 @@ record_alias_subset (superset, subset)
|
|||
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,
|
||||
|
|
@ -644,7 +644,7 @@ record_alias_subset (superset, subset)
|
|||
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;
|
||||
|
|
@ -654,7 +654,7 @@ record_alias_subset (superset, subset)
|
|||
}
|
||||
|
||||
/* 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);
|
||||
}
|
||||
}
|
||||
|
|
@ -687,15 +687,15 @@ record_component_aliases (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,
|
||||
{
|
||||
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)));
|
||||
|
|
@ -1120,7 +1120,7 @@ rtx_equal_for_memref_p (x, y)
|
|||
|
||||
case LABEL_REF:
|
||||
return XEXP (x, 0) == XEXP (y, 0);
|
||||
|
||||
|
||||
case SYMBOL_REF:
|
||||
return XSTR (x, 0) == XSTR (y, 0);
|
||||
|
||||
|
|
@ -1257,7 +1257,7 @@ find_base_term (x)
|
|||
|
||||
case TRUNCATE:
|
||||
if (GET_MODE_SIZE (GET_MODE (x)) < GET_MODE_SIZE (Pmode))
|
||||
return 0;
|
||||
return 0;
|
||||
/* Fall through. */
|
||||
case HIGH:
|
||||
case PRE_INC:
|
||||
|
|
@ -1311,7 +1311,7 @@ find_base_term (x)
|
|||
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);
|
||||
|
||||
|
|
@ -1409,7 +1409,7 @@ base_alias_check (x, y, x_mode, y_mode)
|
|||
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,
|
||||
|
|
@ -1484,7 +1484,7 @@ addr_side_effect_eval (addr, size, n_refs)
|
|||
int n_refs;
|
||||
{
|
||||
int offset = 0;
|
||||
|
||||
|
||||
switch (GET_CODE (addr))
|
||||
{
|
||||
case PRE_INC:
|
||||
|
|
@ -1503,7 +1503,7 @@ addr_side_effect_eval (addr, size, n_refs)
|
|||
default:
|
||||
return addr;
|
||||
}
|
||||
|
||||
|
||||
if (offset)
|
||||
addr = gen_rtx_PLUS (GET_MODE (addr), XEXP (addr, 0), GEN_INT (offset));
|
||||
else
|
||||
|
|
@ -1666,7 +1666,7 @@ memrefs_conflict_p (xsize, x, ysize, y, c)
|
|||
}
|
||||
|
||||
/* 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)
|
||||
|
|
@ -1678,7 +1678,7 @@ memrefs_conflict_p (xsize, x, 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)))
|
||||
|
|
@ -1740,7 +1740,7 @@ memrefs_conflict_p (xsize, x, ysize, y, c)
|
|||
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
|
||||
|
|
@ -1767,23 +1767,23 @@ read_dependence (mem, x)
|
|||
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. */
|
||||
|
|
@ -1803,7 +1803,7 @@ aliases_everything_p (mem)
|
|||
/* If the address is an AND, its very hard to know at what it is
|
||||
actually pointing. */
|
||||
return 1;
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -1861,7 +1861,7 @@ nonoverlapping_component_refs_p (x, y)
|
|||
while (x && y
|
||||
&& TREE_CODE (x) == COMPONENT_REF
|
||||
&& TREE_CODE (y) == COMPONENT_REF);
|
||||
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -1894,7 +1894,7 @@ adjust_offset_for_component_ref (x, offset)
|
|||
return NULL_RTX;
|
||||
|
||||
ioffset = INTVAL (offset);
|
||||
do
|
||||
do
|
||||
{
|
||||
tree field = TREE_OPERAND (x, 1);
|
||||
|
||||
|
|
@ -1980,15 +1980,15 @@ nonoverlapping_memrefs_p (x, y)
|
|||
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 ? (int) GET_MODE_SIZE (GET_MODE (rtlx))
|
||||
: MEM_SIZE (rtlx) ? INTVAL (MEM_SIZE (rtlx))
|
||||
|
|
@ -2105,9 +2105,9 @@ true_dependence (mem, mem_mode, x, varies)
|
|||
}
|
||||
|
||||
/* 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
|
||||
|
|
@ -2233,7 +2233,7 @@ write_dependence_p (mem, x, writep)
|
|||
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);
|
||||
|
||||
|
|
@ -2378,9 +2378,9 @@ nonlocal_mentioned_p (x)
|
|||
x = CALL_INSN_FUNCTION_USAGE (x);
|
||||
if (x == 0)
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
else
|
||||
x = PATTERN (x);
|
||||
x = PATTERN (x);
|
||||
}
|
||||
|
||||
return for_each_rtx (&x, nonlocal_mentioned_p_1, NULL);
|
||||
|
|
@ -2476,9 +2476,9 @@ nonlocal_referenced_p (x)
|
|||
x = CALL_INSN_FUNCTION_USAGE (x);
|
||||
if (x == 0)
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
else
|
||||
x = PATTERN (x);
|
||||
x = PATTERN (x);
|
||||
}
|
||||
|
||||
return for_each_rtx (&x, nonlocal_referenced_p_1, NULL);
|
||||
|
|
@ -2556,9 +2556,9 @@ nonlocal_set_p (x)
|
|||
x = CALL_INSN_FUNCTION_USAGE (x);
|
||||
if (x == 0)
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
else
|
||||
x = PATTERN (x);
|
||||
x = PATTERN (x);
|
||||
}
|
||||
|
||||
return for_each_rtx (&x, nonlocal_set_p_1, NULL);
|
||||
|
|
@ -2597,16 +2597,16 @@ mark_constant_function ()
|
|||
|
||||
if (nonlocal_set_p (insn) || global_reg_mentioned_p (insn)
|
||||
|| volatile_refs_p (PATTERN (insn)))
|
||||
break;
|
||||
break;
|
||||
|
||||
if (! nonlocal_memory_referenced)
|
||||
nonlocal_memory_referenced = nonlocal_referenced_p (insn);
|
||||
}
|
||||
|
||||
|
||||
end_alias_analysis ();
|
||||
|
||||
|
||||
/* Mark the function. */
|
||||
|
||||
|
||||
if (insn)
|
||||
;
|
||||
else if (nonlocal_memory_referenced)
|
||||
|
|
@ -2651,10 +2651,10 @@ init_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;
|
||||
|
||||
|
|
|
|||
|
|
@ -323,7 +323,7 @@ split_specs_attrs (specs_attrs, declspecs, prefix_attributes)
|
|||
tree t, s, a, next, specs, attrs;
|
||||
|
||||
/* This can happen after an __extension__ in pedantic mode. */
|
||||
if (specs_attrs != NULL_TREE
|
||||
if (specs_attrs != NULL_TREE
|
||||
&& TREE_CODE (specs_attrs) == INTEGER_CST)
|
||||
{
|
||||
*declspecs = NULL_TREE;
|
||||
|
|
|
|||
|
|
@ -122,9 +122,9 @@ make_reorder_chain ()
|
|||
next = bb;
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
if (next)
|
||||
prev = make_reorder_chain_1 (next, prev);
|
||||
prev = make_reorder_chain_1 (next, prev);
|
||||
}
|
||||
while (next);
|
||||
RBI (prev)->next = NULL;
|
||||
|
|
|
|||
|
|
@ -236,7 +236,7 @@ bitmap_clear (head)
|
|||
bitmap_free = element;
|
||||
}
|
||||
|
||||
head->first = head->current = 0;
|
||||
head->first = head->current = 0;
|
||||
}
|
||||
|
||||
/* Copy a bitmap to another bitmap. */
|
||||
|
|
@ -397,7 +397,7 @@ bitmap_bit_p (head, bit)
|
|||
/* Return the bit number of the first set bit in the bitmap, or -1
|
||||
if the bitmap is empty. */
|
||||
|
||||
int
|
||||
int
|
||||
bitmap_first_set_bit (a)
|
||||
bitmap a;
|
||||
{
|
||||
|
|
@ -450,7 +450,7 @@ bitmap_first_set_bit (a)
|
|||
/* Return the bit number of the last set bit in the bitmap, or -1
|
||||
if the bitmap is empty. */
|
||||
|
||||
int
|
||||
int
|
||||
bitmap_last_set_bit (a)
|
||||
bitmap a;
|
||||
{
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
|
|||
02111-1307, USA. */
|
||||
|
||||
#ifndef GCC_BITMAP_H
|
||||
#define GCC_BITMAP_H
|
||||
#define GCC_BITMAP_H
|
||||
|
||||
/* Number of words to use for each element in the linked list. */
|
||||
|
||||
|
|
@ -129,7 +129,7 @@ do { \
|
|||
bitmap temp_bitmap_ = (bitmap) alloca (sizeof (bitmap_head)); \
|
||||
(PTR) = bitmap_initialize (temp_bitmap_); \
|
||||
} while (0)
|
||||
|
||||
|
||||
/* Allocate a bitmap with xmalloc. */
|
||||
#define BITMAP_XMALLOC() \
|
||||
bitmap_initialize ((bitmap) xmalloc (sizeof (bitmap_head)))
|
||||
|
|
|
|||
184
gcc/builtins.c
184
gcc/builtins.c
|
|
@ -101,7 +101,7 @@ static rtx expand_builtin_va_start PARAMS ((int, tree));
|
|||
static rtx expand_builtin_va_end PARAMS ((tree));
|
||||
static rtx expand_builtin_va_copy PARAMS ((tree));
|
||||
static rtx expand_builtin_memcmp PARAMS ((tree, tree, rtx,
|
||||
enum machine_mode));
|
||||
enum machine_mode));
|
||||
static rtx expand_builtin_strcmp PARAMS ((tree, rtx,
|
||||
enum machine_mode));
|
||||
static rtx expand_builtin_strncmp PARAMS ((tree, rtx,
|
||||
|
|
@ -117,9 +117,9 @@ static rtx expand_builtin_strspn PARAMS ((tree, rtx,
|
|||
static rtx expand_builtin_strcspn PARAMS ((tree, rtx,
|
||||
enum machine_mode));
|
||||
static rtx expand_builtin_memcpy PARAMS ((tree, rtx,
|
||||
enum machine_mode));
|
||||
enum machine_mode));
|
||||
static rtx expand_builtin_strcpy PARAMS ((tree, rtx,
|
||||
enum machine_mode));
|
||||
enum machine_mode));
|
||||
static rtx builtin_strncpy_read_str PARAMS ((PTR, HOST_WIDE_INT,
|
||||
enum machine_mode));
|
||||
static rtx expand_builtin_strncpy PARAMS ((tree, rtx,
|
||||
|
|
@ -129,7 +129,7 @@ static rtx builtin_memset_read_str PARAMS ((PTR, HOST_WIDE_INT,
|
|||
static rtx builtin_memset_gen_str PARAMS ((PTR, HOST_WIDE_INT,
|
||||
enum machine_mode));
|
||||
static rtx expand_builtin_memset PARAMS ((tree, rtx,
|
||||
enum machine_mode));
|
||||
enum machine_mode));
|
||||
static rtx expand_builtin_bzero PARAMS ((tree));
|
||||
static rtx expand_builtin_strlen PARAMS ((tree, rtx));
|
||||
static rtx expand_builtin_strstr PARAMS ((tree, rtx,
|
||||
|
|
@ -512,7 +512,7 @@ expand_builtin_setjmp_setup (buf_addr, receiver_label)
|
|||
|
||||
void
|
||||
expand_builtin_setjmp_receiver (receiver_label)
|
||||
rtx receiver_label ATTRIBUTE_UNUSED;
|
||||
rtx receiver_label ATTRIBUTE_UNUSED;
|
||||
{
|
||||
/* Clobber the FP when we get here, so we have to make sure it's
|
||||
marked as used by this function. */
|
||||
|
|
@ -718,7 +718,7 @@ expand_builtin_longjmp (buf_addr, value)
|
|||
break;
|
||||
}
|
||||
else if (GET_CODE (insn) == CALL_INSN)
|
||||
break;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -744,7 +744,7 @@ expand_builtin_prefetch (arglist)
|
|||
{
|
||||
arg1 = TREE_VALUE (TREE_CHAIN (arglist));
|
||||
if (TREE_CHAIN (TREE_CHAIN (arglist)))
|
||||
arg2 = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
|
||||
arg2 = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
|
||||
else
|
||||
arg2 = build_int_2 (3, 0);
|
||||
}
|
||||
|
|
@ -760,8 +760,8 @@ expand_builtin_prefetch (arglist)
|
|||
/* Argument 1 (read/write flag) must be a compile-time constant int. */
|
||||
if (TREE_CODE (arg1) != INTEGER_CST)
|
||||
{
|
||||
error ("second arg to `__builtin_prefetch' must be a constant");
|
||||
arg1 = integer_zero_node;
|
||||
error ("second arg to `__builtin_prefetch' must be a constant");
|
||||
arg1 = integer_zero_node;
|
||||
}
|
||||
op1 = expand_expr (arg1, NULL_RTX, VOIDmode, 0);
|
||||
/* Argument 1 must be either zero or one. */
|
||||
|
|
@ -791,14 +791,14 @@ expand_builtin_prefetch (arglist)
|
|||
if ((! (*insn_data[(int)CODE_FOR_prefetch].operand[0].predicate)
|
||||
(op0,
|
||||
insn_data[(int)CODE_FOR_prefetch].operand[0].mode)) ||
|
||||
(GET_MODE(op0) != Pmode))
|
||||
{
|
||||
(GET_MODE(op0) != Pmode))
|
||||
{
|
||||
#ifdef POINTERS_EXTEND_UNSIGNED
|
||||
if (GET_MODE(op0) != Pmode)
|
||||
op0 = convert_memory_address (Pmode, op0);
|
||||
#endif
|
||||
op0 = force_reg (Pmode, op0);
|
||||
}
|
||||
op0 = force_reg (Pmode, op0);
|
||||
}
|
||||
emit_insn (gen_prefetch (op0, op1, op2));
|
||||
}
|
||||
else
|
||||
|
|
@ -1556,16 +1556,16 @@ expand_builtin_mathfn (exp, target, subtarget)
|
|||
0, lab1);
|
||||
|
||||
#ifdef TARGET_EDOM
|
||||
{
|
||||
{
|
||||
#ifdef GEN_ERRNO_RTX
|
||||
rtx errno_rtx = GEN_ERRNO_RTX;
|
||||
rtx errno_rtx = GEN_ERRNO_RTX;
|
||||
#else
|
||||
rtx errno_rtx
|
||||
= gen_rtx_MEM (word_mode, gen_rtx_SYMBOL_REF (Pmode, "errno"));
|
||||
rtx errno_rtx
|
||||
= gen_rtx_MEM (word_mode, gen_rtx_SYMBOL_REF (Pmode, "errno"));
|
||||
#endif
|
||||
|
||||
emit_move_insn (errno_rtx, GEN_INT (TARGET_EDOM));
|
||||
}
|
||||
emit_move_insn (errno_rtx, GEN_INT (TARGET_EDOM));
|
||||
}
|
||||
#else
|
||||
/* We can't set errno=EDOM directly; let the library call do it.
|
||||
Pop the arguments right away in case the call gets deleted. */
|
||||
|
|
@ -1948,20 +1948,20 @@ expand_builtin_memcpy (arglist, target, mode)
|
|||
|
||||
/* If DEST is not a pointer type, call the normal function. */
|
||||
if (dest_align == 0)
|
||||
return 0;
|
||||
return 0;
|
||||
|
||||
/* If the LEN parameter is zero, return DEST. */
|
||||
if (host_integerp (len, 1) && tree_low_cst (len, 1) == 0)
|
||||
{
|
||||
/* Evaluate and ignore SRC in case it has side-effects. */
|
||||
expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
|
||||
return expand_expr (dest, target, mode, EXPAND_NORMAL);
|
||||
}
|
||||
{
|
||||
/* Evaluate and ignore SRC in case it has side-effects. */
|
||||
expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
|
||||
return expand_expr (dest, target, mode, EXPAND_NORMAL);
|
||||
}
|
||||
|
||||
/* If either SRC is not a pointer type, don't do this
|
||||
operation in-line. */
|
||||
if (src_align == 0)
|
||||
return 0;
|
||||
return 0;
|
||||
|
||||
dest_mem = get_memory_rtx (dest);
|
||||
set_mem_align (dest_mem, dest_align);
|
||||
|
|
@ -2024,7 +2024,7 @@ expand_builtin_strcpy (exp, target, mode)
|
|||
len = size_binop (PLUS_EXPR, len, ssize_int (1));
|
||||
chainon (arglist, build_tree_list (NULL_TREE, len));
|
||||
return expand_expr (build_function_call_expr (fn, arglist),
|
||||
target, mode, EXPAND_NORMAL);
|
||||
target, mode, EXPAND_NORMAL);
|
||||
}
|
||||
|
||||
/* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
|
||||
|
|
@ -2069,9 +2069,9 @@ expand_builtin_strncpy (arglist, target, mode)
|
|||
|
||||
/* If the len parameter is zero, return the dst parameter. */
|
||||
if (integer_zerop (len))
|
||||
{
|
||||
/* Evaluate and ignore the src argument in case it has
|
||||
side-effects. */
|
||||
{
|
||||
/* Evaluate and ignore the src argument in case it has
|
||||
side-effects. */
|
||||
expand_expr (TREE_VALUE (TREE_CHAIN (arglist)), const0_rtx,
|
||||
VOIDmode, EXPAND_NORMAL);
|
||||
/* Return the dst parameter. */
|
||||
|
|
@ -2112,9 +2112,9 @@ expand_builtin_strncpy (arglist, target, mode)
|
|||
/* OK transform into builtin memcpy. */
|
||||
fn = built_in_decls[BUILT_IN_MEMCPY];
|
||||
if (!fn)
|
||||
return 0;
|
||||
return 0;
|
||||
return expand_expr (build_function_call_expr (fn, arglist),
|
||||
target, mode, EXPAND_NORMAL);
|
||||
target, mode, EXPAND_NORMAL);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -2198,41 +2198,41 @@ expand_builtin_memset (exp, target, mode)
|
|||
|
||||
/* If the LEN parameter is zero, return DEST. */
|
||||
if (host_integerp (len, 1) && tree_low_cst (len, 1) == 0)
|
||||
{
|
||||
/* Evaluate and ignore VAL in case it has side-effects. */
|
||||
expand_expr (val, const0_rtx, VOIDmode, EXPAND_NORMAL);
|
||||
return expand_expr (dest, target, mode, EXPAND_NORMAL);
|
||||
}
|
||||
{
|
||||
/* Evaluate and ignore VAL in case it has side-effects. */
|
||||
expand_expr (val, const0_rtx, VOIDmode, EXPAND_NORMAL);
|
||||
return expand_expr (dest, target, mode, EXPAND_NORMAL);
|
||||
}
|
||||
|
||||
if (TREE_CODE (val) != INTEGER_CST)
|
||||
{
|
||||
rtx val_rtx;
|
||||
{
|
||||
rtx val_rtx;
|
||||
|
||||
if (!host_integerp (len, 1))
|
||||
return 0;
|
||||
|
||||
if (optimize_size && tree_low_cst (len, 1) > 1)
|
||||
return 0;
|
||||
|
||||
/* Assume that we can memset by pieces if we can store the
|
||||
* the coefficients by pieces (in the required modes).
|
||||
* We can't pass builtin_memset_gen_str as that emits RTL. */
|
||||
c = 1;
|
||||
if (!can_store_by_pieces (tree_low_cst (len, 1),
|
||||
builtin_memset_read_str,
|
||||
(PTR) &c, dest_align))
|
||||
if (!host_integerp (len, 1))
|
||||
return 0;
|
||||
|
||||
val = fold (build1 (CONVERT_EXPR, unsigned_char_type_node, val));
|
||||
val_rtx = expand_expr (val, NULL_RTX, VOIDmode, 0);
|
||||
val_rtx = force_reg (TYPE_MODE (unsigned_char_type_node),
|
||||
val_rtx);
|
||||
if (optimize_size && tree_low_cst (len, 1) > 1)
|
||||
return 0;
|
||||
|
||||
/* Assume that we can memset by pieces if we can store the
|
||||
* the coefficients by pieces (in the required modes).
|
||||
* We can't pass builtin_memset_gen_str as that emits RTL. */
|
||||
c = 1;
|
||||
if (!can_store_by_pieces (tree_low_cst (len, 1),
|
||||
builtin_memset_read_str,
|
||||
(PTR) &c, dest_align))
|
||||
return 0;
|
||||
|
||||
val = fold (build1 (CONVERT_EXPR, unsigned_char_type_node, val));
|
||||
val_rtx = expand_expr (val, NULL_RTX, VOIDmode, 0);
|
||||
val_rtx = force_reg (TYPE_MODE (unsigned_char_type_node),
|
||||
val_rtx);
|
||||
dest_mem = get_memory_rtx (dest);
|
||||
store_by_pieces (dest_mem, tree_low_cst (len, 1),
|
||||
builtin_memset_gen_str,
|
||||
(PTR)val_rtx, dest_align);
|
||||
return force_operand (XEXP (dest_mem, 0), NULL_RTX);
|
||||
}
|
||||
}
|
||||
|
||||
if (target_char_cast (val, &c))
|
||||
return 0;
|
||||
|
|
@ -2317,7 +2317,7 @@ expand_builtin_memcmp (exp, arglist, target, mode)
|
|||
const char *p1, *p2;
|
||||
|
||||
if (!validate_arglist (arglist,
|
||||
POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
|
||||
POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
|
||||
return 0;
|
||||
|
||||
arg1 = TREE_VALUE (arglist);
|
||||
|
|
@ -2356,12 +2356,12 @@ expand_builtin_memcmp (exp, arglist, target, mode)
|
|||
tree cst_uchar_ptr_node = build_pointer_type (cst_uchar_node);
|
||||
tree ind1 =
|
||||
fold (build1 (CONVERT_EXPR, integer_type_node,
|
||||
build1 (INDIRECT_REF, cst_uchar_node,
|
||||
build1 (NOP_EXPR, cst_uchar_ptr_node, arg1))));
|
||||
build1 (INDIRECT_REF, cst_uchar_node,
|
||||
build1 (NOP_EXPR, cst_uchar_ptr_node, arg1))));
|
||||
tree ind2 =
|
||||
fold (build1 (CONVERT_EXPR, integer_type_node,
|
||||
build1 (INDIRECT_REF, cst_uchar_node,
|
||||
build1 (NOP_EXPR, cst_uchar_ptr_node, arg2))));
|
||||
build1 (INDIRECT_REF, cst_uchar_node,
|
||||
build1 (NOP_EXPR, cst_uchar_ptr_node, arg2))));
|
||||
tree result = fold (build (MINUS_EXPR, integer_type_node, ind1, ind2));
|
||||
return expand_expr (result, target, mode, EXPAND_NORMAL);
|
||||
}
|
||||
|
|
@ -2498,12 +2498,12 @@ expand_builtin_strcmp (exp, target, mode)
|
|||
if (!len || TREE_CODE (len) != INTEGER_CST)
|
||||
{
|
||||
if (len2 && !TREE_SIDE_EFFECTS (len2))
|
||||
len = len2;
|
||||
len = len2;
|
||||
else if (len == 0)
|
||||
return 0;
|
||||
return 0;
|
||||
}
|
||||
else if (len2 && TREE_CODE (len2) == INTEGER_CST
|
||||
&& tree_int_cst_lt (len2, len))
|
||||
&& tree_int_cst_lt (len2, len))
|
||||
len = len2;
|
||||
|
||||
/* If both arguments have side effects, we cannot optimize. */
|
||||
|
|
@ -2516,7 +2516,7 @@ expand_builtin_strcmp (exp, target, mode)
|
|||
|
||||
chainon (arglist, build_tree_list (NULL_TREE, len));
|
||||
return expand_expr (build_function_call_expr (fn, arglist),
|
||||
target, mode, EXPAND_NORMAL);
|
||||
target, mode, EXPAND_NORMAL);
|
||||
}
|
||||
|
||||
/* Expand expression EXP, which is a call to the strncmp builtin. Return 0
|
||||
|
|
@ -2544,23 +2544,23 @@ expand_builtin_strncmp (exp, target, mode)
|
|||
|
||||
/* If the len parameter is zero, return zero. */
|
||||
if (host_integerp (arg3, 1) && tree_low_cst (arg3, 1) == 0)
|
||||
{
|
||||
/* Evaluate and ignore arg1 and arg2 in case they have
|
||||
side-effects. */
|
||||
expand_expr (arg1, const0_rtx, VOIDmode, EXPAND_NORMAL);
|
||||
expand_expr (arg2, const0_rtx, VOIDmode, EXPAND_NORMAL);
|
||||
return const0_rtx;
|
||||
}
|
||||
{
|
||||
/* Evaluate and ignore arg1 and arg2 in case they have
|
||||
side-effects. */
|
||||
expand_expr (arg1, const0_rtx, VOIDmode, EXPAND_NORMAL);
|
||||
expand_expr (arg2, const0_rtx, VOIDmode, EXPAND_NORMAL);
|
||||
return const0_rtx;
|
||||
}
|
||||
|
||||
p1 = c_getstr (arg1);
|
||||
p2 = c_getstr (arg2);
|
||||
|
||||
/* If all arguments are constant, evaluate at compile-time. */
|
||||
if (host_integerp (arg3, 1) && p1 && p2)
|
||||
{
|
||||
const int r = strncmp (p1, p2, tree_low_cst (arg3, 1));
|
||||
return (r < 0 ? constm1_rtx : (r > 0 ? const1_rtx : const0_rtx));
|
||||
}
|
||||
{
|
||||
const int r = strncmp (p1, p2, tree_low_cst (arg3, 1));
|
||||
return (r < 0 ? constm1_rtx : (r > 0 ? const1_rtx : const0_rtx));
|
||||
}
|
||||
|
||||
/* If len == 1 or (either string parameter is "" and (len >= 1)),
|
||||
return (*(const u_char*)arg1 - *(const u_char*)arg2). */
|
||||
|
|
@ -2618,7 +2618,7 @@ expand_builtin_strncmp (exp, target, mode)
|
|||
newarglist = tree_cons (NULL_TREE, arg2, newarglist);
|
||||
newarglist = tree_cons (NULL_TREE, arg1, newarglist);
|
||||
return expand_expr (build_function_call_expr (fn, newarglist),
|
||||
target, mode, EXPAND_NORMAL);
|
||||
target, mode, EXPAND_NORMAL);
|
||||
}
|
||||
|
||||
/* Expand expression EXP, which is a call to the strcat builtin.
|
||||
|
|
@ -2670,7 +2670,7 @@ expand_builtin_strncat (arglist, target, mode)
|
|||
/* If the requested length is zero, or the src parameter string
|
||||
length is zero, return the dst parameter. */
|
||||
if (integer_zerop (len) || (p && *p == '\0'))
|
||||
{
|
||||
{
|
||||
/* Evaluate and ignore the src and len parameters in case
|
||||
they have side-effects. */
|
||||
expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
|
||||
|
|
@ -2682,7 +2682,7 @@ expand_builtin_strncat (arglist, target, mode)
|
|||
length, call strcat. */
|
||||
if (TREE_CODE (len) == INTEGER_CST && p
|
||||
&& compare_tree_int (len, strlen (p)) >= 0)
|
||||
{
|
||||
{
|
||||
tree newarglist
|
||||
= tree_cons (NULL_TREE, dst, build_tree_list (NULL_TREE, src));
|
||||
tree fn = built_in_decls[BUILT_IN_STRCAT];
|
||||
|
|
@ -2718,14 +2718,14 @@ expand_builtin_strspn (arglist, target, mode)
|
|||
|
||||
/* If both arguments are constants, evaluate at compile-time. */
|
||||
if (p1 && p2)
|
||||
{
|
||||
{
|
||||
const size_t r = strspn (p1, p2);
|
||||
return expand_expr (size_int (r), target, mode, EXPAND_NORMAL);
|
||||
}
|
||||
|
||||
/* If either argument is "", return 0. */
|
||||
if ((p1 && *p1 == '\0') || (p2 && *p2 == '\0'))
|
||||
{
|
||||
{
|
||||
/* Evaluate and ignore both arguments in case either one has
|
||||
side-effects. */
|
||||
expand_expr (s1, const0_rtx, VOIDmode, EXPAND_NORMAL);
|
||||
|
|
@ -2755,14 +2755,14 @@ expand_builtin_strcspn (arglist, target, mode)
|
|||
|
||||
/* If both arguments are constants, evaluate at compile-time. */
|
||||
if (p1 && p2)
|
||||
{
|
||||
{
|
||||
const size_t r = strcspn (p1, p2);
|
||||
return expand_expr (size_int (r), target, mode, EXPAND_NORMAL);
|
||||
}
|
||||
|
||||
/* If the first argument is "", return 0. */
|
||||
if (p1 && *p1 == '\0')
|
||||
{
|
||||
{
|
||||
/* Evaluate and ignore argument s2 in case it has
|
||||
side-effects. */
|
||||
expand_expr (s2, const0_rtx, VOIDmode, EXPAND_NORMAL);
|
||||
|
|
@ -2771,7 +2771,7 @@ expand_builtin_strcspn (arglist, target, mode)
|
|||
|
||||
/* If the second argument is "", return __builtin_strlen(s1). */
|
||||
if (p2 && *p2 == '\0')
|
||||
{
|
||||
{
|
||||
tree newarglist = build_tree_list (NULL_TREE, s1),
|
||||
fn = built_in_decls[BUILT_IN_STRLEN];
|
||||
|
||||
|
|
@ -3708,11 +3708,11 @@ expand_builtin (exp, target, subtarget, mode, ignore)
|
|||
case BUILT_IN_FPUTC_UNLOCKED:
|
||||
case BUILT_IN_FPUTS_UNLOCKED:
|
||||
case BUILT_IN_FWRITE_UNLOCKED:
|
||||
return expand_call (exp, target, ignore);
|
||||
return expand_call (exp, target, ignore);
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
switch (fcode)
|
||||
{
|
||||
|
|
@ -3824,11 +3824,11 @@ expand_builtin (exp, target, subtarget, mode, ignore)
|
|||
0 otherwise. */
|
||||
case BUILT_IN_AGGREGATE_INCOMING_ADDRESS:
|
||||
if (arglist != 0
|
||||
|| ! AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl)))
|
||||
|| GET_CODE (DECL_RTL (DECL_RESULT (current_function_decl))) != MEM)
|
||||
return const0_rtx;
|
||||
|| ! AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl)))
|
||||
|| GET_CODE (DECL_RTL (DECL_RESULT (current_function_decl))) != MEM)
|
||||
return const0_rtx;
|
||||
else
|
||||
return XEXP (DECL_RTL (DECL_RESULT (current_function_decl)), 0);
|
||||
return XEXP (DECL_RTL (DECL_RESULT (current_function_decl)), 0);
|
||||
|
||||
case BUILT_IN_ALLOCA:
|
||||
target = expand_builtin_alloca (arglist, target);
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue