git
/
gcc
mirror of git://gcc.gnu.org/git/gcc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

fold-const.c: Convert prototypes to ISO C90. 

* fold-const.c: Convert prototypes to ISO C90.
	* function.c: Likewise.
	* function.h: Likewise.

From-SVN: r68778
This commit is contained in:
Andreas Jaeger 2003-07-01 18:20:39 +02:00
parent b69cd3cfcf
commit fa8db1f7c4
3 changed files with 365 additions and 720 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

460
gcc/fold-const.c
View File

@ -57,64 +57,56 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
#include "hashtab.h" #include "hashtab.h"
#include "langhooks.h" #include "langhooks.h"
static void encode PARAMS ((HOST_WIDE_INT *, static void encode (HOST_WIDE_INT *, unsigned HOST_WIDE_INT, HOST_WIDE_INT);
unsigned HOST_WIDE_INT, static void decode (HOST_WIDE_INT *, unsigned HOST_WIDE_INT *, HOST_WIDE_INT *);
HOST_WIDE_INT)); static bool negate_expr_p (tree);
static void decode PARAMS ((HOST_WIDE_INT *, static tree negate_expr (tree);
unsigned HOST_WIDE_INT *, static tree split_tree (tree, enum tree_code, tree *, tree *, tree *, int);
HOST_WIDE_INT *)); static tree associate_trees (tree, tree, enum tree_code, tree);
static bool negate_expr_p PARAMS ((tree)); static tree int_const_binop (enum tree_code, tree, tree, int);
static tree negate_expr PARAMS ((tree)); static tree const_binop (enum tree_code, tree, tree, int);
static tree split_tree PARAMS ((tree, enum tree_code, tree *, tree *, static hashval_t size_htab_hash (const void *);
tree *, int)); static int size_htab_eq (const void *, const void *);
static tree associate_trees PARAMS ((tree, tree, enum tree_code, tree)); static tree fold_convert (tree, tree);
static tree int_const_binop PARAMS ((enum tree_code, tree, tree, int)); static enum tree_code invert_tree_comparison (enum tree_code);
static tree const_binop PARAMS ((enum tree_code, tree, tree, int)); static enum tree_code swap_tree_comparison (enum tree_code);
static hashval_t size_htab_hash PARAMS ((const void *)); static int comparison_to_compcode (enum tree_code);
static int size_htab_eq PARAMS ((const void *, const void *)); static enum tree_code compcode_to_comparison (int);
static tree fold_convert PARAMS ((tree, tree)); static int truth_value_p (enum tree_code);
static enum tree_code invert_tree_comparison PARAMS ((enum tree_code)); static int operand_equal_for_comparison_p (tree, tree, tree);
static enum tree_code swap_tree_comparison PARAMS ((enum tree_code)); static int twoval_comparison_p (tree, tree *, tree *, int *);
static int comparison_to_compcode PARAMS ((enum tree_code)); static tree eval_subst (tree, tree, tree, tree, tree);
static enum tree_code compcode_to_comparison PARAMS ((int)); static tree pedantic_omit_one_operand (tree, tree, tree);
static int truth_value_p PARAMS ((enum tree_code)); static tree distribute_bit_expr (enum tree_code, tree, tree, tree);
static int operand_equal_for_comparison_p PARAMS ((tree, tree, tree)); static tree make_bit_field_ref (tree, tree, int, int, int);
static int twoval_comparison_p PARAMS ((tree, tree *, tree *, int *)); static tree optimize_bit_field_compare (enum tree_code, tree, tree, tree);
static tree eval_subst PARAMS ((tree, tree, tree, tree, tree)); static tree decode_field_reference (tree, HOST_WIDE_INT *, HOST_WIDE_INT *,
static tree pedantic_omit_one_operand PARAMS ((tree, tree, tree)); enum machine_mode *, int *, int *,
static tree distribute_bit_expr PARAMS ((enum tree_code, tree, tree, tree)); tree *, tree *);
static tree make_bit_field_ref PARAMS ((tree, tree, int, int, int)); static int all_ones_mask_p (tree, int);
static tree optimize_bit_field_compare PARAMS ((enum tree_code, tree, static tree sign_bit_p (tree, tree);
tree, tree)); static int simple_operand_p (tree);
static tree decode_field_reference PARAMS ((tree, HOST_WIDE_INT *, static tree range_binop (enum tree_code, tree, tree, int, tree, int);
HOST_WIDE_INT *, static tree make_range (tree, int *, tree *, tree *);
enum machine_mode *, int *, static tree build_range_check (tree, tree, int, tree, tree);
int *, tree *, tree *)); static int merge_ranges (int *, tree *, tree *, int, tree, tree, int, tree,
static int all_ones_mask_p PARAMS ((tree, int)); tree);
static tree sign_bit_p PARAMS ((tree, tree)); static tree fold_range_test (tree);
static int simple_operand_p PARAMS ((tree)); static tree unextend (tree, int, int, tree);
static tree range_binop PARAMS ((enum tree_code, tree, tree, int, static tree fold_truthop (enum tree_code, tree, tree, tree);
tree, int)); static tree optimize_minmax_comparison (tree);
static tree make_range PARAMS ((tree, int *, tree *, tree *)); static tree extract_muldiv (tree, tree, enum tree_code, tree);
static tree build_range_check PARAMS ((tree, tree, int, tree, tree)); static tree extract_muldiv_1 (tree, tree, enum tree_code, tree);
static int merge_ranges PARAMS ((int *, tree *, tree *, int, tree, tree, static tree strip_compound_expr (tree, tree);
int, tree, tree)); static int multiple_of_p (tree, tree, tree);
static tree fold_range_test PARAMS ((tree)); static tree constant_boolean_node (int, tree);
static tree unextend PARAMS ((tree, int, int, tree)); static int count_cond (tree, int);
static tree fold_truthop PARAMS ((enum tree_code, tree, tree, tree)); static tree fold_binary_op_with_conditional_arg (enum tree_code, tree, tree,
static tree optimize_minmax_comparison PARAMS ((tree)); tree, int);
static tree extract_muldiv PARAMS ((tree, tree, enum tree_code, tree)); static bool fold_real_zero_addition_p (tree, tree, int);
static tree extract_muldiv_1 PARAMS ((tree, tree, enum tree_code, tree)); static tree fold_mathfn_compare (enum built_in_function, enum tree_code,
static tree strip_compound_expr PARAMS ((tree, tree)); tree, tree, tree);
static int multiple_of_p PARAMS ((tree, tree, tree)); static tree fold_inf_compare (enum tree_code, tree, tree, tree);
static tree constant_boolean_node PARAMS ((int, tree));
static int count_cond PARAMS ((tree, int));
static tree fold_binary_op_with_conditional_arg
PARAMS ((enum tree_code, tree, tree, tree, int));
static bool fold_real_zero_addition_p PARAMS ((tree, tree, int));
static tree fold_mathfn_compare PARAMS ((enum built_in_function,
enum tree_code, tree, tree, tree));
static tree fold_inf_compare PARAMS ((enum tree_code, tree, tree, tree));
/* The following constants represent a bit based encoding of GCC's /* The following constants represent a bit based encoding of GCC's
comparison operators. This encoding simplifies transformations comparison operators. This encoding simplifies transformations
@ -154,10 +146,7 @@ static tree fold_inf_compare PARAMS ((enum tree_code, tree, tree, tree));
WORDS points to the array of HOST_WIDE_INTs. */ WORDS points to the array of HOST_WIDE_INTs. */
static void static void
encode (words, low, hi) encode (HOST_WIDE_INT *words, unsigned HOST_WIDE_INT low, HOST_WIDE_INT hi)
HOST_WIDE_INT *words;
unsigned HOST_WIDE_INT low;
HOST_WIDE_INT hi;
{ {
words[0] = LOWPART (low); words[0] = LOWPART (low);
words[1] = HIGHPART (low); words[1] = HIGHPART (low);
@ -170,10 +159,7 @@ encode (words, low, hi)
The integer is stored into *LOW and *HI as two `HOST_WIDE_INT' pieces. */ The integer is stored into *LOW and *HI as two `HOST_WIDE_INT' pieces. */
static void static void
decode (words, low, hi) decode (HOST_WIDE_INT *words, unsigned HOST_WIDE_INT *low, HOST_WIDE_INT *hi)
HOST_WIDE_INT *words;
unsigned HOST_WIDE_INT *low;
HOST_WIDE_INT *hi;
{ {
*low = words[0] + words[1] * BASE; *low = words[0] + words[1] * BASE;
*hi = words[2] + words[3] * BASE; *hi = words[2] + words[3] * BASE;
@ -187,9 +173,7 @@ decode (words, low, hi)
propagate it. */ propagate it. */
int int
force_fit_type (t, overflow) force_fit_type (tree t, int overflow)
tree t;
int overflow;
{ {
unsigned HOST_WIDE_INT low; unsigned HOST_WIDE_INT low;
HOST_WIDE_INT high; HOST_WIDE_INT high;
@ -268,11 +252,8 @@ force_fit_type (t, overflow)
The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV. */ The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV. */
int int
add_double (l1, h1, l2, h2, lv, hv) add_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1, unsigned HOST_WIDE_INT l2,
unsigned HOST_WIDE_INT l1, l2; HOST_WIDE_INT h2, unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv)
HOST_WIDE_INT h1, h2;
unsigned HOST_WIDE_INT *lv;
HOST_WIDE_INT *hv;
{ {
unsigned HOST_WIDE_INT l; unsigned HOST_WIDE_INT l;
HOST_WIDE_INT h; HOST_WIDE_INT h;
@ -291,11 +272,8 @@ add_double (l1, h1, l2, h2, lv, hv)
The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV. */ The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV. */
int int
neg_double (l1, h1, lv, hv) neg_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1, unsigned HOST_WIDE_INT *lv,
unsigned HOST_WIDE_INT l1; HOST_WIDE_INT *hv)
HOST_WIDE_INT h1;
unsigned HOST_WIDE_INT *lv;
HOST_WIDE_INT *hv;
{ {
if (l1 == 0) if (l1 == 0)
{ {
@ -318,11 +296,8 @@ neg_double (l1, h1, lv, hv)
The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV. */ The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV. */
int int
mul_double (l1, h1, l2, h2, lv, hv) mul_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1, unsigned HOST_WIDE_INT l2,
unsigned HOST_WIDE_INT l1, l2; HOST_WIDE_INT h2, unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv)
HOST_WIDE_INT h1, h2;
unsigned HOST_WIDE_INT *lv;
HOST_WIDE_INT *hv;
{ {
HOST_WIDE_INT arg1[4]; HOST_WIDE_INT arg1[4];
HOST_WIDE_INT arg2[4]; HOST_WIDE_INT arg2[4];
@ -378,13 +353,9 @@ mul_double (l1, h1, l2, h2, lv, hv)
Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */ Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */
void void
lshift_double (l1, h1, count, prec, lv, hv, arith) lshift_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1, HOST_WIDE_INT count,
unsigned HOST_WIDE_INT l1; unsigned int prec, unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv,
HOST_WIDE_INT h1, count; int arith)
unsigned int prec;
unsigned HOST_WIDE_INT *lv;
HOST_WIDE_INT *hv;
int arith;
{ {
unsigned HOST_WIDE_INT signmask; unsigned HOST_WIDE_INT signmask;
@ -446,13 +417,9 @@ lshift_double (l1, h1, count, prec, lv, hv, arith)
Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */ Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */
void void
rshift_double (l1, h1, count, prec, lv, hv, arith) rshift_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1, HOST_WIDE_INT count,
unsigned HOST_WIDE_INT l1; unsigned int prec, unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv,
HOST_WIDE_INT h1, count; int arith)
unsigned int prec;
unsigned HOST_WIDE_INT *lv;
HOST_WIDE_INT *hv;
int arith;
{ {
unsigned HOST_WIDE_INT signmask; unsigned HOST_WIDE_INT signmask;
@ -512,12 +479,8 @@ rshift_double (l1, h1, count, prec, lv, hv, arith)
Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */ Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */
void void
lrotate_double (l1, h1, count, prec, lv, hv) lrotate_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1, HOST_WIDE_INT count,
unsigned HOST_WIDE_INT l1; unsigned int prec, unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv)
HOST_WIDE_INT h1, count;
unsigned int prec;
unsigned HOST_WIDE_INT *lv;
HOST_WIDE_INT *hv;
{ {
unsigned HOST_WIDE_INT s1l, s2l; unsigned HOST_WIDE_INT s1l, s2l;
HOST_WIDE_INT s1h, s2h; HOST_WIDE_INT s1h, s2h;
@ -537,12 +500,8 @@ lrotate_double (l1, h1, count, prec, lv, hv)
Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */ Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */
void void
rrotate_double (l1, h1, count, prec, lv, hv) rrotate_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1, HOST_WIDE_INT count,
unsigned HOST_WIDE_INT l1; unsigned int prec, unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv)
HOST_WIDE_INT h1, count;
unsigned int prec;
unsigned HOST_WIDE_INT *lv;
HOST_WIDE_INT *hv;
{ {
unsigned HOST_WIDE_INT s1l, s2l; unsigned HOST_WIDE_INT s1l, s2l;
HOST_WIDE_INT s1h, s2h; HOST_WIDE_INT s1h, s2h;
@ -567,17 +526,13 @@ rrotate_double (l1, h1, count, prec, lv, hv)
UNS nonzero says do unsigned division. */ UNS nonzero says do unsigned division. */
int int
div_and_round_double (code, uns, div_and_round_double (enum tree_code code, int uns,
lnum_orig, hnum_orig, lden_orig, hden_orig, unsigned HOST_WIDE_INT lnum_orig, /* num == numerator == dividend */
lquo, hquo, lrem, hrem) HOST_WIDE_INT hnum_orig,
enum tree_code code; unsigned HOST_WIDE_INT lden_orig, /* den == denominator == divisor */
int uns; HOST_WIDE_INT hden_orig, unsigned HOST_WIDE_INT *lquo,
unsigned HOST_WIDE_INT lnum_orig; /* num == numerator == dividend */ HOST_WIDE_INT *hquo, unsigned HOST_WIDE_INT *lrem,
HOST_WIDE_INT hnum_orig; HOST_WIDE_INT *hrem)
unsigned HOST_WIDE_INT lden_orig; /* den == denominator == divisor */
HOST_WIDE_INT hden_orig;
unsigned HOST_WIDE_INT *lquo, *lrem;
HOST_WIDE_INT *hquo, *hrem;
{ {
int quo_neg = 0; int quo_neg = 0;
HOST_WIDE_INT num[4 + 1]; /* extra element for scaling. */ HOST_WIDE_INT num[4 + 1]; /* extra element for scaling. */
@ -842,8 +797,7 @@ div_and_round_double (code, uns,
the function negate_expr. */ the function negate_expr. */
static bool static bool
negate_expr_p (t) negate_expr_p (tree t)
tree t;
{ {
unsigned HOST_WIDE_INT val; unsigned HOST_WIDE_INT val;
unsigned int prec; unsigned int prec;
@ -891,8 +845,7 @@ negate_expr_p (t)
null, in which case return null. */ null, in which case return null. */
static tree static tree
negate_expr (t) negate_expr (tree t)
tree t;
{ {
tree type; tree type;
tree tem; tree tem;
@ -953,11 +906,7 @@ negate_expr (t)
same type as IN, but they will have the same signedness and mode. */ same type as IN, but they will have the same signedness and mode. */
static tree static tree
split_tree (in, code, conp, litp, minus_litp, negate_p) split_tree (tree in, enum tree_code code, tree *conp, tree *litp, tree *minus_litp, int negate_p)
tree in;
enum tree_code code;
tree *conp, *litp, *minus_litp;
int negate_p;
{ {
tree var = 0; tree var = 0;
@ -1035,10 +984,7 @@ split_tree (in, code, conp, litp, minus_litp, negate_p)
we build an operation, do it in TYPE and with CODE. */ we build an operation, do it in TYPE and with CODE. */
static tree static tree
associate_trees (t1, t2, code, type) associate_trees (tree t1, tree t2, enum tree_code code, tree type)
tree t1, t2;
enum tree_code code;
tree type;
{ {
if (t1 == 0) if (t1 == 0)
return t2; return t2;
@ -1072,10 +1018,7 @@ associate_trees (t1, t2, code, type)
If NOTRUNC is nonzero, do not truncate the result to fit the data type. */ If NOTRUNC is nonzero, do not truncate the result to fit the data type. */
static tree static tree
int_const_binop (code, arg1, arg2, notrunc) int_const_binop (enum tree_code code, tree arg1, tree arg2, int notrunc)
enum tree_code code;
tree arg1, arg2;
int notrunc;
{ {
unsigned HOST_WIDE_INT int1l, int2l; unsigned HOST_WIDE_INT int1l, int2l;
HOST_WIDE_INT int1h, int2h; HOST_WIDE_INT int1h, int2h;
@ -1267,10 +1210,7 @@ int_const_binop (code, arg1, arg2, notrunc)
If NOTRUNC is nonzero, do not truncate the result to fit the data type. */ If NOTRUNC is nonzero, do not truncate the result to fit the data type. */
static tree static tree
const_binop (code, arg1, arg2, notrunc) const_binop (enum tree_code code, tree arg1, tree arg2, int notrunc)
enum tree_code code;
tree arg1, arg2;
int notrunc;
{ {
STRIP_NOPS (arg1); STRIP_NOPS (arg1);
STRIP_NOPS (arg2); STRIP_NOPS (arg2);
@ -1395,8 +1335,7 @@ const_binop (code, arg1, arg2, notrunc)
/* Return the hash code code X, an INTEGER_CST. */ /* Return the hash code code X, an INTEGER_CST. */
static hashval_t static hashval_t
size_htab_hash (x) size_htab_hash (const void *x)
const void *x;
{ {
tree t = (tree) x; tree t = (tree) x;
@ -1409,9 +1348,7 @@ size_htab_hash (x)
is the same as that given by *Y, which is the same. */ is the same as that given by *Y, which is the same. */
static int static int
size_htab_eq (x, y) size_htab_eq (const void *x, const void *y)
const void *x;
const void *y;
{ {
tree xt = (tree) x; tree xt = (tree) x;
tree yt = (tree) y; tree yt = (tree) y;
@ -1426,9 +1363,7 @@ size_htab_eq (x, y)
bits are given by NUMBER and of the sizetype represented by KIND. */ bits are given by NUMBER and of the sizetype represented by KIND. */
tree tree
size_int_wide (number, kind) size_int_wide (HOST_WIDE_INT number, enum size_type_kind kind)
HOST_WIDE_INT number;
enum size_type_kind kind;
{ {
return size_int_type_wide (number, sizetype_tab[(int) kind]); return size_int_type_wide (number, sizetype_tab[(int) kind]);
} }
@ -1440,9 +1375,7 @@ static GTY ((if_marked ("ggc_marked_p"), param_is (union tree_node)))
htab_t size_htab; htab_t size_htab;
tree tree
size_int_type_wide (number, type) size_int_type_wide (HOST_WIDE_INT number, tree type)
HOST_WIDE_INT number;
tree type;
{ {
void **slot; void **slot;
@ -1480,9 +1413,7 @@ size_int_type_wide (number, type)
If the operands are constant, so is the result. */ If the operands are constant, so is the result. */
tree tree
size_binop (code, arg0, arg1) size_binop (enum tree_code code, tree arg0, tree arg1)
enum tree_code code;
tree arg0, arg1;
{ {
tree type = TREE_TYPE (arg0); tree type = TREE_TYPE (arg0);
@ -1517,8 +1448,7 @@ size_binop (code, arg0, arg1)
in signed type corresponding to the type of the operands. */ in signed type corresponding to the type of the operands. */
tree tree
size_diffop (arg0, arg1) size_diffop (tree arg0, tree arg1)
tree arg0, arg1;
{ {
tree type = TREE_TYPE (arg0); tree type = TREE_TYPE (arg0);
tree ctype; tree ctype;
@ -1559,9 +1489,7 @@ size_diffop (arg0, arg1)
return a constant tree representing the result of conversion. */ return a constant tree representing the result of conversion. */
static tree static tree
fold_convert (t, arg1) fold_convert (tree t, tree arg1)
tree t;
tree arg1;
{ {
tree type = TREE_TYPE (t); tree type = TREE_TYPE (t);
int overflow = 0; int overflow = 0;
@ -1680,8 +1608,7 @@ fold_convert (t, arg1)
/* Return an expr equal to X but certainly not valid as an lvalue. */ /* Return an expr equal to X but certainly not valid as an lvalue. */
tree tree
non_lvalue (x) non_lvalue (tree x)
tree x;
{ {
tree result; tree result;
@ -1707,8 +1634,7 @@ int pedantic_lvalues;
pedantic lvalue. Otherwise, return X. */ pedantic lvalue. Otherwise, return X. */
tree tree
pedantic_non_lvalue (x) pedantic_non_lvalue (tree x)
tree x;
{ {
if (pedantic_lvalues) if (pedantic_lvalues)
return non_lvalue (x); return non_lvalue (x);
@ -1721,8 +1647,7 @@ pedantic_non_lvalue (x)
comparisons, except for NE_EXPR and EQ_EXPR. */ comparisons, except for NE_EXPR and EQ_EXPR. */
static enum tree_code static enum tree_code
invert_tree_comparison (code) invert_tree_comparison (enum tree_code code)
enum tree_code code;
{ {
switch (code) switch (code)
{ {
@ -1747,8 +1672,7 @@ invert_tree_comparison (code)
swapped. This is safe for floating-point. */ swapped. This is safe for floating-point. */
static enum tree_code static enum tree_code
swap_tree_comparison (code) swap_tree_comparison (enum tree_code code)
enum tree_code code;
{ {
switch (code) switch (code)
{ {
@ -1774,8 +1698,7 @@ swap_tree_comparison (code)
compcode_to_comparison. */ compcode_to_comparison. */
static int static int
comparison_to_compcode (code) comparison_to_compcode (enum tree_code code)
enum tree_code code;
{ {
switch (code) switch (code)
{ {
@ -1801,8 +1724,7 @@ comparison_to_compcode (code)
inverse of comparison_to_compcode. */ inverse of comparison_to_compcode. */
static enum tree_code static enum tree_code
compcode_to_comparison (code) compcode_to_comparison (int code)
int code;
{ {
switch (code) switch (code)
{ {
@ -1826,8 +1748,7 @@ compcode_to_comparison (code)
/* Return nonzero if CODE is a tree code that represents a truth value. */ /* Return nonzero if CODE is a tree code that represents a truth value. */
static int static int
truth_value_p (code) truth_value_p (enum tree_code code)
enum tree_code code;
{ {
return (TREE_CODE_CLASS (code) == '<' return (TREE_CODE_CLASS (code) == '<'
|| code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR || code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR
@ -1844,9 +1765,7 @@ truth_value_p (code)
(2) two NaNs may be indistinguishable, but NaN!=NaN. */ (2) two NaNs may be indistinguishable, but NaN!=NaN. */
int int
operand_equal_p (arg0, arg1, only_const) operand_equal_p (tree arg0, tree arg1, int only_const)
tree arg0, arg1;
int only_const;
{ {
/* If both types don't have the same signedness, then we can't consider /* If both types don't have the same signedness, then we can't consider
them equal. We must check this before the STRIP_NOPS calls them equal. We must check this before the STRIP_NOPS calls
@ -2067,9 +1986,7 @@ operand_equal_p (arg0, arg1, only_const)
When in doubt, return 0. */ When in doubt, return 0. */
static int static int
operand_equal_for_comparison_p (arg0, arg1, other) operand_equal_for_comparison_p (tree arg0, tree arg1, tree other)
tree arg0, arg1;
tree other;
{ {
int unsignedp1, unsignedpo; int unsignedp1, unsignedpo;
tree primarg0, primarg1, primother; tree primarg0, primarg1, primother;
@ -2130,10 +2047,7 @@ operand_equal_for_comparison_p (arg0, arg1, other)
If this is true, return 1. Otherwise, return zero. */ If this is true, return 1. Otherwise, return zero. */
static int static int
twoval_comparison_p (arg, cval1, cval2, save_p) twoval_comparison_p (tree arg, tree *cval1, tree *cval2, int *save_p)
tree arg;
tree *cval1, *cval2;
int *save_p;
{ {
enum tree_code code = TREE_CODE (arg); enum tree_code code = TREE_CODE (arg);
char class = TREE_CODE_CLASS (code); char class = TREE_CODE_CLASS (code);
@ -2225,9 +2139,7 @@ twoval_comparison_p (arg, cval1, cval2, save_p)
NEW1 and OLD1. */ NEW1 and OLD1. */
static tree static tree
eval_subst (arg, old0, new0, old1, new1) eval_subst (tree arg, tree old0, tree new0, tree old1, tree new1)
tree arg;
tree old0, new0, old1, new1;
{ {
tree type = TREE_TYPE (arg); tree type = TREE_TYPE (arg);
enum tree_code code = TREE_CODE (arg); enum tree_code code = TREE_CODE (arg);
@ -2311,8 +2223,7 @@ eval_subst (arg, old0, new0, old1, new1)
the conversion of RESULT to TYPE. */ the conversion of RESULT to TYPE. */
tree tree
omit_one_operand (type, result, omitted) omit_one_operand (tree type, tree result, tree omitted)
tree type, result, omitted;
{ {
tree t = convert (type, result); tree t = convert (type, result);
@ -2325,8 +2236,7 @@ omit_one_operand (type, result, omitted)
/* Similar, but call pedantic_non_lvalue instead of non_lvalue. */ /* Similar, but call pedantic_non_lvalue instead of non_lvalue. */
static tree static tree
pedantic_omit_one_operand (type, result, omitted) pedantic_omit_one_operand (tree type, tree result, tree omitted)
tree type, result, omitted;
{ {
tree t = convert (type, result); tree t = convert (type, result);
@ -2341,8 +2251,7 @@ pedantic_omit_one_operand (type, result, omitted)
returns a truth value (0 or 1). */ returns a truth value (0 or 1). */
tree tree
invert_truthvalue (arg) invert_truthvalue (tree arg)
tree arg;
{ {
tree type = TREE_TYPE (arg); tree type = TREE_TYPE (arg);
enum tree_code code = TREE_CODE (arg); enum tree_code code = TREE_CODE (arg);
@ -2455,16 +2364,13 @@ invert_truthvalue (arg)
operands are another bit-wise operation with a common input. If so, operands are another bit-wise operation with a common input. If so,
distribute the bit operations to save an operation and possibly two if distribute the bit operations to save an operation and possibly two if
constants are involved. For example, convert constants are involved. For example, convert
(A | B) & (A | C) into A | (B & C) (A | B) & (A | C) into A | (B & C)
Further simplification will occur if B and C are constants. Further simplification will occur if B and C are constants.
If this optimization cannot be done, 0 will be returned. */ If this optimization cannot be done, 0 will be returned. */
static tree static tree
distribute_bit_expr (code, type, arg0, arg1) distribute_bit_expr (enum tree_code code, tree type, tree arg0, tree arg1)
enum tree_code code;
tree type;
tree arg0, arg1;
{ {
tree common; tree common;
tree left, right; tree left, right;
@ -2510,11 +2416,7 @@ distribute_bit_expr (code, type, arg0, arg1)
starting at BITPOS. The field is unsigned if UNSIGNEDP is nonzero. */ starting at BITPOS. The field is unsigned if UNSIGNEDP is nonzero. */
static tree static tree
make_bit_field_ref (inner, type, bitsize, bitpos, unsignedp) make_bit_field_ref (tree inner, tree type, int bitsize, int bitpos, int unsignedp)
tree inner;
tree type;
int bitsize, bitpos;
int unsignedp;
{ {
tree result = build (BIT_FIELD_REF, type, inner, tree result = build (BIT_FIELD_REF, type, inner,
size_int (bitsize), bitsize_int (bitpos)); size_int (bitsize), bitsize_int (bitpos));
@ -2545,10 +2447,7 @@ make_bit_field_ref (inner, type, bitsize, bitpos, unsignedp)
tree. Otherwise we return zero. */ tree. Otherwise we return zero. */
static tree static tree
optimize_bit_field_compare (code, compare_type, lhs, rhs) optimize_bit_field_compare (enum tree_code code, tree compare_type, tree lhs, tree rhs)
enum tree_code code;
tree compare_type;
tree lhs, rhs;
{ {
HOST_WIDE_INT lbitpos, lbitsize, rbitpos, rbitsize, nbitpos, nbitsize; HOST_WIDE_INT lbitpos, lbitsize, rbitpos, rbitsize, nbitpos, nbitsize;
tree type = TREE_TYPE (lhs); tree type = TREE_TYPE (lhs);
@ -2722,14 +2621,9 @@ optimize_bit_field_compare (code, compare_type, lhs, rhs)
do anything with. */ do anything with. */
static tree static tree
decode_field_reference (exp, pbitsize, pbitpos, pmode, punsignedp, decode_field_reference (tree exp, HOST_WIDE_INT *pbitsize, HOST_WIDE_INT *pbitpos,
pvolatilep, pmask, pand_mask) enum machine_mode *pmode, int *punsignedp, int *pvolatilep,
tree exp; tree *pmask, tree *pand_mask)
HOST_WIDE_INT *pbitsize, *pbitpos;
enum machine_mode *pmode;
int *punsignedp, *pvolatilep;
tree *pmask;
tree *pand_mask;
{ {
tree and_mask = 0; tree and_mask = 0;
tree mask, inner, offset; tree mask, inner, offset;
@ -2784,9 +2678,7 @@ decode_field_reference (exp, pbitsize, pbitpos, pmode, punsignedp,
bit positions. */ bit positions. */
static int static int
all_ones_mask_p (mask, size) all_ones_mask_p (tree mask, int size)
tree mask;
int size;
{ {
tree type = TREE_TYPE (mask); tree type = TREE_TYPE (mask);
unsigned int precision = TYPE_PRECISION (type); unsigned int precision = TYPE_PRECISION (type);
@ -2811,9 +2703,7 @@ all_ones_mask_p (mask, size)
or NULL_TREE otherwise. */ or NULL_TREE otherwise. */
static tree static tree
sign_bit_p (exp, val) sign_bit_p (tree exp, tree val)
tree exp;
tree val;
{ {
unsigned HOST_WIDE_INT lo; unsigned HOST_WIDE_INT lo;
HOST_WIDE_INT hi; HOST_WIDE_INT hi;
@ -2857,8 +2747,7 @@ sign_bit_p (exp, val)
to be evaluated unconditionally. */ to be evaluated unconditionally. */
static int static int
simple_operand_p (exp) simple_operand_p (tree exp)
tree exp;
{ {
/* Strip any conversions that don't change the machine mode. */ /* Strip any conversions that don't change the machine mode. */
while ((TREE_CODE (exp) == NOP_EXPR while ((TREE_CODE (exp) == NOP_EXPR
@ -2886,9 +2775,9 @@ simple_operand_p (exp)
try to change a logical combination of comparisons into a range test. try to change a logical combination of comparisons into a range test.
For example, both For example, both
X == 2 || X == 3 || X == 4 || X == 5 X == 2 || X == 3 || X == 4 || X == 5
and and
X >= 2 && X <= 5 X >= 2 && X <= 5
are converted to are converted to
(unsigned) (X - 2) <= 3 (unsigned) (X - 2) <= 3
@ -2918,11 +2807,8 @@ simple_operand_p (exp)
type if both are specified. */ type if both are specified. */
static tree static tree
range_binop (code, type, arg0, upper0_p, arg1, upper1_p) range_binop (enum tree_code code, tree type, tree arg0, int upper0_p, tree arg1,
enum tree_code code; int upper1_p)
tree type;
tree arg0, arg1;
int upper0_p, upper1_p;
{ {
tree tem; tree tem;
int result; int result;
@ -2986,10 +2872,7 @@ range_binop (code, type, arg0, upper0_p, arg1, upper1_p)
likely not be returning a useful value and range. */ likely not be returning a useful value and range. */
static tree static tree
make_range (exp, pin_p, plow, phigh) make_range (tree exp, int *pin_p, tree *plow, tree *phigh)
tree exp;
int *pin_p;
tree *plow, *phigh;
{ {
enum tree_code code; enum tree_code code;
tree arg0 = NULL_TREE, arg1 = NULL_TREE, type = NULL_TREE; tree arg0 = NULL_TREE, arg1 = NULL_TREE, type = NULL_TREE;
@ -3254,11 +3137,7 @@ make_range (exp, pin_p, plow, phigh)
on IN_P) the range. */ on IN_P) the range. */
static tree static tree
build_range_check (type, exp, in_p, low, high) build_range_check (tree type, tree exp, int in_p, tree low, tree high)
tree type;
tree exp;
int in_p;
tree low, high;
{ {
tree etype = TREE_TYPE (exp); tree etype = TREE_TYPE (exp);
tree value; tree value;
@ -3334,11 +3213,8 @@ build_range_check (type, exp, in_p, low, high)
can, 0 if we can't. Set the output range into the specified parameters. */ can, 0 if we can't. Set the output range into the specified parameters. */
static int static int
merge_ranges (pin_p, plow, phigh, in0_p, low0, high0, in1_p, low1, high1) merge_ranges (int *pin_p, tree *plow, tree *phigh, int in0_p, tree low0, tree high0,
int *pin_p; int in1_p, tree low1, tree high1)
tree *plow, *phigh;
int in0_p, in1_p;
tree low0, high0, low1, high1;
{ {
int no_overlap; int no_overlap;
int subset; int subset;
@ -3474,8 +3350,7 @@ merge_ranges (pin_p, plow, phigh, in0_p, low0, high0, in1_p, low1, high1)
merge it into some range test. Return the new tree if so. */ merge it into some range test. Return the new tree if so. */
static tree static tree
fold_range_test (exp) fold_range_test (tree exp)
tree exp;
{ {
int or_op = (TREE_CODE (exp) == TRUTH_ORIF_EXPR int or_op = (TREE_CODE (exp) == TRUTH_ORIF_EXPR
|| TREE_CODE (exp) == TRUTH_OR_EXPR); || TREE_CODE (exp) == TRUTH_OR_EXPR);
@ -3547,11 +3422,7 @@ fold_range_test (exp)
it is an INTEGER_CST that should be AND'ed with the extra bits. */ it is an INTEGER_CST that should be AND'ed with the extra bits. */
static tree static tree
unextend (c, p, unsignedp, mask) unextend (tree c, int p, int unsignedp, tree mask)
tree c;
int p;
int unsignedp;
tree mask;
{ {
tree type = TREE_TYPE (c); tree type = TREE_TYPE (c);
int modesize = GET_MODE_BITSIZE (TYPE_MODE (type)); int modesize = GET_MODE_BITSIZE (TYPE_MODE (type));
@ -3611,14 +3482,12 @@ unextend (c, p, unsignedp, mask)
We return the simplified tree or 0 if no optimization is possible. */ We return the simplified tree or 0 if no optimization is possible. */
static tree static tree
fold_truthop (code, truth_type, lhs, rhs) fold_truthop (enum tree_code code, tree truth_type, tree lhs, tree rhs)
enum tree_code code;
tree truth_type, lhs, rhs;
{ {
/* If this is the "or" of two comparisons, we can do something if /* If this is the "or" of two comparisons, we can do something if
the comparisons are NE_EXPR. If this is the "and", we can do something the comparisons are NE_EXPR. If this is the "and", we can do something
if the comparisons are EQ_EXPR. I.e., if the comparisons are EQ_EXPR. I.e.,
(a->b == 2 && a->c == 4) can become (a->new == NEW). (a->b == 2 && a->c == 4) can become (a->new == NEW).
WANTED_CODE is this operation code. For single bit fields, we can WANTED_CODE is this operation code. For single bit fields, we can
convert EQ_EXPR to NE_EXPR so we need not reject the "wrong" convert EQ_EXPR to NE_EXPR so we need not reject the "wrong"
@ -4037,8 +3906,7 @@ fold_truthop (code, truth_type, lhs, rhs)
constant. */ constant. */
static tree static tree
optimize_minmax_comparison (t) optimize_minmax_comparison (tree t)
tree t;
{ {
tree type = TREE_TYPE (t); tree type = TREE_TYPE (t);
tree arg0 = TREE_OPERAND (t, 0); tree arg0 = TREE_OPERAND (t, 0);
@ -4149,11 +4017,7 @@ optimize_minmax_comparison (t)
original computation, but need not be in the original type. */ original computation, but need not be in the original type. */
static tree static tree
extract_muldiv (t, c, code, wide_type) extract_muldiv (tree t, tree c, enum tree_code code, tree wide_type)
tree t;
tree c;
enum tree_code code;
tree wide_type;
{ {
/* To avoid exponential search depth, refuse to allow recursion past /* To avoid exponential search depth, refuse to allow recursion past
three levels. Beyond that (1) it's highly unlikely that we'll find three levels. Beyond that (1) it's highly unlikely that we'll find
@ -4174,11 +4038,7 @@ extract_muldiv (t, c, code, wide_type)
} }
static tree static tree
extract_muldiv_1 (t, c, code, wide_type) extract_muldiv_1 (tree t, tree c, enum tree_code code, tree wide_type)
tree t;
tree c;
enum tree_code code;
tree wide_type;
{ {
tree type = TREE_TYPE (t); tree type = TREE_TYPE (t);
enum tree_code tcode = TREE_CODE (t); enum tree_code tcode = TREE_CODE (t);
@ -4464,9 +4324,7 @@ extract_muldiv_1 (t, c, code, wide_type)
that we may sometimes modify the tree. */ that we may sometimes modify the tree. */
static tree static tree
strip_compound_expr (t, s) strip_compound_expr (tree t, tree s)
tree t;
tree s;
{ {
enum tree_code code = TREE_CODE (t); enum tree_code code = TREE_CODE (t);
@ -4499,9 +4357,7 @@ strip_compound_expr (t, s)
1), and is of the indicated TYPE. */ 1), and is of the indicated TYPE. */
static tree static tree
constant_boolean_node (value, type) constant_boolean_node (int value, tree type)
int value;
tree type;
{ {
if (type == integer_type_node) if (type == integer_type_node)
return value ? integer_one_node : integer_zero_node; return value ? integer_one_node : integer_zero_node;
@ -4522,9 +4378,7 @@ constant_boolean_node (value, type)
we don't care (to avoid spending too much time on complex expressions.). */ we don't care (to avoid spending too much time on complex expressions.). */
static int static int
count_cond (expr, lim) count_cond (tree expr, int lim)
tree expr;
int lim;
{ {
int ctrue, cfalse; int ctrue, cfalse;
@ -4547,12 +4401,7 @@ count_cond (expr, lim)
original expression. */ original expression. */
static tree static tree
fold_binary_op_with_conditional_arg (code, type, cond, arg, cond_first_p) fold_binary_op_with_conditional_arg (enum tree_code code, tree type, tree cond, tree arg, int cond_first_p)
enum tree_code code;
tree type;
tree cond;
tree arg;
int cond_first_p;
{ {
tree test, true_value, false_value; tree test, true_value, false_value;
tree lhs = NULL_TREE; tree lhs = NULL_TREE;
@ -4693,9 +4542,7 @@ fold_binary_op_with_conditional_arg (code, type, cond, arg, cond_first_p)
modes, X + 0 is not the same as X because -0 + 0 is 0. */ modes, X + 0 is not the same as X because -0 + 0 is 0. */
static bool static bool
fold_real_zero_addition_p (type, addend, negate) fold_real_zero_addition_p (tree type, tree addend, int negate)
tree type, addend;
int negate;
{ {
if (!real_zerop (addend)) if (!real_zerop (addend))
return false; return false;
@ -4732,10 +4579,7 @@ fold_real_zero_addition_p (type, addend, negate)
can be made, and NULL_TREE otherwise. */ can be made, and NULL_TREE otherwise. */
static tree static tree
fold_mathfn_compare (fcode, code, type, arg0, arg1) fold_mathfn_compare (enum built_in_function fcode, enum tree_code code, tree type, tree arg0, tree arg1)
enum built_in_function fcode;
enum tree_code code;
tree type, arg0, arg1;
{ {
REAL_VALUE_TYPE c; REAL_VALUE_TYPE c;
@ -4869,9 +4713,7 @@ fold_mathfn_compare (fcode, code, type, arg0, arg1)
can be made, and NULL_TREE otherwise. */ can be made, and NULL_TREE otherwise. */
static tree static tree
fold_inf_compare (code, type, arg0, arg1) fold_inf_compare (enum tree_code code, tree type, tree arg0, tree arg1)
enum tree_code code;
tree type, arg0, arg1;
{ {
enum machine_mode mode; enum machine_mode mode;
REAL_VALUE_TYPE max; REAL_VALUE_TYPE max;
@ -4950,8 +4792,7 @@ fold_inf_compare (code, type, arg0, arg1)
but we can constant-fold them if they have constant operands. */ but we can constant-fold them if they have constant operands. */
tree tree
fold (expr) fold (tree expr)
tree expr;
{ {
tree t = expr; tree t = expr;
tree t1 = NULL_TREE; tree t1 = NULL_TREE;
@ -5342,7 +5183,7 @@ fold (expr)
{ {
tree uns = (*lang_hooks.types.unsigned_type) (TREE_TYPE (and0)); tree uns = (*lang_hooks.types.unsigned_type) (TREE_TYPE (and0));
and0 = convert (uns, and0); and0 = convert (uns, and0);
and1 = convert (uns, and1); and1 = convert (uns, and1);
} }
#endif #endif
} }
@ -5409,7 +5250,7 @@ fold (expr)
tree targ0 = strip_float_extensions (arg0); tree targ0 = strip_float_extensions (arg0);
if (targ0 != arg0) if (targ0 != arg0)
return convert (type, build1 (NEGATE_EXPR, TREE_TYPE (targ0), targ0)); return convert (type, build1 (NEGATE_EXPR, TREE_TYPE (targ0), targ0));
} }
/* Convert - (a - b) to (b - a) for non-floating-point. */ /* Convert - (a - b) to (b - a) for non-floating-point. */
@ -5583,15 +5424,15 @@ fold (expr)
if (TREE_CODE (parg0) == MULT_EXPR if (TREE_CODE (parg0) == MULT_EXPR
&& TREE_CODE (parg1) != MULT_EXPR) && TREE_CODE (parg1) != MULT_EXPR)
return fold (build (PLUS_EXPR, type, return fold (build (PLUS_EXPR, type,
fold (build (PLUS_EXPR, type, fold (build (PLUS_EXPR, type,
convert (type, parg0), convert (type, parg0),
convert (type, marg))), convert (type, marg))),
convert (type, parg1))); convert (type, parg1)));
if (TREE_CODE (parg0) != MULT_EXPR if (TREE_CODE (parg0) != MULT_EXPR
&& TREE_CODE (parg1) == MULT_EXPR) && TREE_CODE (parg1) == MULT_EXPR)
return fold (build (PLUS_EXPR, type, return fold (build (PLUS_EXPR, type,
fold (build (PLUS_EXPR, type, fold (build (PLUS_EXPR, type,
convert (type, parg1), convert (type, parg1),
convert (type, marg))), convert (type, marg))),
convert (type, parg0))); convert (type, parg0)));
} }
@ -6235,8 +6076,8 @@ fold (expr)
{ {
return fold (build (MULT_EXPR, type, return fold (build (MULT_EXPR, type,
build (RDIV_EXPR, type, arg0, build (RDIV_EXPR, type, arg0,
TREE_OPERAND (arg1, 0)), TREE_OPERAND (arg1, 0)),
TREE_OPERAND (arg1, 1))); TREE_OPERAND (arg1, 1)));
} }
if (flag_unsafe_math_optimizations) if (flag_unsafe_math_optimizations)
@ -7373,7 +7214,7 @@ fold (expr)
/* Optimize comparisons of strlen vs zero to a compare of the /* Optimize comparisons of strlen vs zero to a compare of the
first character of the string vs zero. To wit, first character of the string vs zero. To wit,
strlen(ptr) == 0 => *ptr == 0 strlen(ptr) == 0 => *ptr == 0
strlen(ptr) != 0 => *ptr != 0 strlen(ptr) != 0 => *ptr != 0
Other cases should reduce to one of these two (or a constant) Other cases should reduce to one of these two (or a constant)
due to the return value of strlen being unsigned. */ due to the return value of strlen being unsigned. */
@ -7969,10 +7810,7 @@ fold (expr)
transformed version). */ transformed version). */
static int static int
multiple_of_p (type, top, bottom) multiple_of_p (tree type, tree top, tree bottom)
tree type;
tree top;
tree bottom;
{ {
if (operand_equal_p (top, bottom, 0)) if (operand_equal_p (top, bottom, 0))
return 1; return 1;
@ -8039,8 +7877,7 @@ multiple_of_p (type, top, bottom)
/* Return true if `t' is known to be non-negative. */ /* Return true if `t' is known to be non-negative. */
int int
tree_expr_nonnegative_p (t) tree_expr_nonnegative_p (tree t)
tree t;
{ {
switch (TREE_CODE (t)) switch (TREE_CODE (t))
{ {
@ -8238,8 +8075,7 @@ tree_expr_nonnegative_p (t)
Only handles constants at the moment. */ Only handles constants at the moment. */
int int
rtl_expr_nonnegative_p (r) rtl_expr_nonnegative_p (rtx r)
rtx r;
{ {
switch (GET_CODE (r)) switch (GET_CODE (r))
{ {

577
gcc/function.c
View File

File diff suppressed because it is too large Load Diff

48
gcc/function.h
View File

@ -1,6 +1,6 @@
/* Structure for saving state for a nested function. /* Structure for saving state for a nested function.
Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
1999, 2000 Free Software Foundation, Inc. 1999, 2000, 2003 Free Software Foundation, Inc.
This file is part of GCC. This file is part of GCC.
@ -62,7 +62,7 @@ struct emit_status GTY(())
/* The ends of the doubly-linked chain of rtl for the current function. /* The ends of the doubly-linked chain of rtl for the current function.
Both are reset to null at the start of rtl generation for the function. Both are reset to null at the start of rtl generation for the function.
start_sequence saves both of these on `sequence_stack' along with start_sequence saves both of these on `sequence_stack' along with
`sequence_rtl_expr' and then starts a new, nested sequence of insns. */ `sequence_rtl_expr' and then starts a new, nested sequence of insns. */
rtx x_first_insn; rtx x_first_insn;
@ -100,7 +100,7 @@ struct emit_status GTY(())
regno_pointer_align; regno_pointer_align;
/* Indexed by pseudo register number, gives the rtx for that pseudo. /* Indexed by pseudo register number, gives the rtx for that pseudo.
Allocated in parallel with regno_pointer_align. Allocated in parallel with regno_pointer_align.
Note MEM expressions can appear in this array due to the actions Note MEM expressions can appear in this array due to the actions
of put_var_into_stack. */ of put_var_into_stack. */
@ -350,7 +350,7 @@ struct function GTY(())
until no longer needed. CLEANUP_POINT_EXPRs define the lifetime until no longer needed. CLEANUP_POINT_EXPRs define the lifetime
of TARGET_EXPRs. */ of TARGET_EXPRs. */
int x_target_temp_slot_level; int x_target_temp_slot_level;
/* This slot is initialized as 0 and is added to /* This slot is initialized as 0 and is added to
during the nested function. */ during the nested function. */
struct var_refs_queue *fixup_var_refs_queue; struct var_refs_queue *fixup_var_refs_queue;
@ -398,7 +398,7 @@ struct function GTY(())
/* Nonzero if function being compiled needs to /* Nonzero if function being compiled needs to
return the address of where it has put a structure value. */ return the address of where it has put a structure value. */
unsigned int returns_pcc_struct : 1; unsigned int returns_pcc_struct : 1;
/* Nonzero if the current function returns a pointer type. */ /* Nonzero if the current function returns a pointer type. */
unsigned int returns_pointer : 1; unsigned int returns_pointer : 1;
@ -410,7 +410,7 @@ struct function GTY(())
/* Nonzero if function being compiled can call longjmp. */ /* Nonzero if function being compiled can call longjmp. */
unsigned int calls_longjmp : 1; unsigned int calls_longjmp : 1;
/* Nonzero if function being compiled can call alloca, /* Nonzero if function being compiled can call alloca,
either as a subroutine or builtin. */ either as a subroutine or builtin. */
unsigned int calls_alloca : 1; unsigned int calls_alloca : 1;
@ -446,7 +446,7 @@ struct function GTY(())
function, however, should be treated as throwing if any of its callees function, however, should be treated as throwing if any of its callees
can throw. */ can throw. */
unsigned int all_throwers_are_sibcalls : 1; unsigned int all_throwers_are_sibcalls : 1;
/* Nonzero if instrumentation calls for function entry and exit should be /* Nonzero if instrumentation calls for function entry and exit should be
generated. */ generated. */
unsigned int instrument_entry_exit : 1; unsigned int instrument_entry_exit : 1;
@ -579,45 +579,45 @@ extern tree inline_function_decl;
/* Given a function decl for a containing function, /* Given a function decl for a containing function,
return the `struct function' for it. */ return the `struct function' for it. */
struct function *find_function_data PARAMS ((tree)); struct function *find_function_data (tree);
/* Set NOTE_BLOCK for each block note in the current function. */ /* Set NOTE_BLOCK for each block note in the current function. */
extern void identify_blocks PARAMS ((void)); extern void identify_blocks (void);
/* Identify BLOCKs referenced by more than one NOTE_INSN_BLOCK_{BEG,END}, /* Identify BLOCKs referenced by more than one NOTE_INSN_BLOCK_{BEG,END},
and create duplicate blocks. */ and create duplicate blocks. */
extern void reorder_blocks PARAMS ((void)); extern void reorder_blocks (void);
/* Set BLOCK_NUMBER for all the blocks in FN. */ /* Set BLOCK_NUMBER for all the blocks in FN. */
extern void number_blocks PARAMS ((tree)); extern void number_blocks (tree);
/* Return size needed for stack frame based on slots so far allocated. /* Return size needed for stack frame based on slots so far allocated.
This size counts from zero. It is not rounded to STACK_BOUNDARY; This size counts from zero. It is not rounded to STACK_BOUNDARY;
the caller may have to do that. */ the caller may have to do that. */
extern HOST_WIDE_INT get_frame_size PARAMS ((void)); extern HOST_WIDE_INT get_frame_size (void);
/* Likewise, but for a different than the current function. */ /* Likewise, but for a different than the current function. */
extern HOST_WIDE_INT get_func_frame_size PARAMS ((struct function *)); extern HOST_WIDE_INT get_func_frame_size (struct function *);
/* A pointer to a function to create target specific, per-function /* A pointer to a function to create target specific, per-function
data structures. */ data structures. */
extern struct machine_function * (*init_machine_status) PARAMS ((void)); extern struct machine_function * (*init_machine_status) (void);
/* Save and restore status information for a nested function. */ /* Save and restore status information for a nested function. */
extern void restore_emit_status PARAMS ((struct function *)); extern void restore_emit_status (struct function *);
extern void free_after_parsing PARAMS ((struct function *)); extern void free_after_parsing (struct function *);
extern void free_after_compilation PARAMS ((struct function *)); extern void free_after_compilation (struct function *);
extern void init_varasm_status PARAMS ((struct function *)); extern void init_varasm_status (struct function *);
#ifdef RTX_CODE #ifdef RTX_CODE
extern void diddle_return_value PARAMS ((void (*)(rtx, void*), void*)); extern void diddle_return_value (void (*)(rtx, void*), void*);
extern void clobber_return_register PARAMS ((void)); extern void clobber_return_register (void);
extern void use_return_register PARAMS ((void)); extern void use_return_register (void);
#endif #endif
extern rtx get_arg_pointer_save_area PARAMS ((struct function *)); extern rtx get_arg_pointer_save_area (struct function *);
extern void init_virtual_regs PARAMS ((struct emit_status *)); extern void init_virtual_regs (struct emit_status *);
/* Called once, at initialization, to initialize function.c. */ /* Called once, at initialization, to initialize function.c. */
extern void init_function_once PARAMS ((void)); extern void init_function_once (void);