* predict.h: Convert to ISO C90 prototypes.
* predict.c: Likewise.
* tree-dump.h: Likewise.
* tree-dump.c: Likewise.
* diagnostic.h: Likewise.
* diagnostic.c: Likewise.
* combine.c: Likewise.
* rtl.h: Convert prototypes of combine.c to ISO C90.
From-SVN: r67626
static int n_occurrences;
-static void do_SUBST PARAMS ((rtx *, rtx));
-static void do_SUBST_INT PARAMS ((int *, int));
-static void init_reg_last_arrays PARAMS ((void));
-static void setup_incoming_promotions PARAMS ((void));
-static void set_nonzero_bits_and_sign_copies PARAMS ((rtx, rtx, void *));
-static int cant_combine_insn_p PARAMS ((rtx));
-static int can_combine_p PARAMS ((rtx, rtx, rtx, rtx, rtx *, rtx *));
-static int sets_function_arg_p PARAMS ((rtx));
-static int combinable_i3pat PARAMS ((rtx, rtx *, rtx, rtx, int, rtx *));
-static int contains_muldiv PARAMS ((rtx));
-static rtx try_combine PARAMS ((rtx, rtx, rtx, int *));
-static void undo_all PARAMS ((void));
-static void undo_commit PARAMS ((void));
-static rtx *find_split_point PARAMS ((rtx *, rtx));
-static rtx subst PARAMS ((rtx, rtx, rtx, int, int));
-static rtx combine_simplify_rtx PARAMS ((rtx, enum machine_mode, int, int));
-static rtx simplify_if_then_else PARAMS ((rtx));
-static rtx simplify_set PARAMS ((rtx));
-static rtx simplify_logical PARAMS ((rtx, int));
-static rtx expand_compound_operation PARAMS ((rtx));
-static rtx expand_field_assignment PARAMS ((rtx));
-static rtx make_extraction PARAMS ((enum machine_mode, rtx, HOST_WIDE_INT,
- rtx, unsigned HOST_WIDE_INT, int,
- int, int));
-static rtx extract_left_shift PARAMS ((rtx, int));
-static rtx make_compound_operation PARAMS ((rtx, enum rtx_code));
-static int get_pos_from_mask PARAMS ((unsigned HOST_WIDE_INT,
- unsigned HOST_WIDE_INT *));
-static rtx force_to_mode PARAMS ((rtx, enum machine_mode,
- unsigned HOST_WIDE_INT, rtx, int));
-static rtx if_then_else_cond PARAMS ((rtx, rtx *, rtx *));
-static rtx known_cond PARAMS ((rtx, enum rtx_code, rtx, rtx));
-static int rtx_equal_for_field_assignment_p PARAMS ((rtx, rtx));
-static rtx make_field_assignment PARAMS ((rtx));
-static rtx apply_distributive_law PARAMS ((rtx));
-static rtx simplify_and_const_int PARAMS ((rtx, enum machine_mode, rtx,
- unsigned HOST_WIDE_INT));
-static unsigned HOST_WIDE_INT cached_nonzero_bits
- PARAMS ((rtx, enum machine_mode, rtx,
- enum machine_mode,
- unsigned HOST_WIDE_INT));
-static unsigned HOST_WIDE_INT nonzero_bits1
- PARAMS ((rtx, enum machine_mode, rtx,
- enum machine_mode,
- unsigned HOST_WIDE_INT));
-static unsigned int cached_num_sign_bit_copies
- PARAMS ((rtx, enum machine_mode, rtx,
- enum machine_mode, unsigned int));
-static unsigned int num_sign_bit_copies1
- PARAMS ((rtx, enum machine_mode, rtx,
- enum machine_mode, unsigned int));
-static int merge_outer_ops PARAMS ((enum rtx_code *, HOST_WIDE_INT *,
- enum rtx_code, HOST_WIDE_INT,
- enum machine_mode, int *));
-static rtx simplify_shift_const PARAMS ((rtx, enum rtx_code, enum machine_mode,
- rtx, int));
-static int recog_for_combine PARAMS ((rtx *, rtx, rtx *));
-static rtx gen_lowpart_for_combine PARAMS ((enum machine_mode, rtx));
-static rtx gen_binary PARAMS ((enum rtx_code, enum machine_mode,
- rtx, rtx));
-static enum rtx_code simplify_comparison PARAMS ((enum rtx_code, rtx *, rtx *));
-static void update_table_tick PARAMS ((rtx));
-static void record_value_for_reg PARAMS ((rtx, rtx, rtx));
-static void check_promoted_subreg PARAMS ((rtx, rtx));
-static void record_dead_and_set_regs_1 PARAMS ((rtx, rtx, void *));
-static void record_dead_and_set_regs PARAMS ((rtx));
-static int get_last_value_validate PARAMS ((rtx *, rtx, int, int));
-static rtx get_last_value PARAMS ((rtx));
-static int use_crosses_set_p PARAMS ((rtx, int));
-static void reg_dead_at_p_1 PARAMS ((rtx, rtx, void *));
-static int reg_dead_at_p PARAMS ((rtx, rtx));
-static void move_deaths PARAMS ((rtx, rtx, int, rtx, rtx *));
-static int reg_bitfield_target_p PARAMS ((rtx, rtx));
-static void distribute_notes PARAMS ((rtx, rtx, rtx, rtx));
-static void distribute_links PARAMS ((rtx));
-static void mark_used_regs_combine PARAMS ((rtx));
-static int insn_cuid PARAMS ((rtx));
-static void record_promoted_value PARAMS ((rtx, rtx));
-static rtx reversed_comparison PARAMS ((rtx, enum machine_mode, rtx, rtx));
-static enum rtx_code combine_reversed_comparison_code PARAMS ((rtx));
+static void do_SUBST (rtx *, rtx);
+static void do_SUBST_INT (int *, int);
+static void init_reg_last_arrays (void);
+static void setup_incoming_promotions (void);
+static void set_nonzero_bits_and_sign_copies (rtx, rtx, void *);
+static int cant_combine_insn_p (rtx);
+static int can_combine_p (rtx, rtx, rtx, rtx, rtx *, rtx *);
+static int sets_function_arg_p (rtx);
+static int combinable_i3pat (rtx, rtx *, rtx, rtx, int, rtx *);
+static int contains_muldiv (rtx);
+static rtx try_combine (rtx, rtx, rtx, int *);
+static void undo_all (void);
+static void undo_commit (void);
+static rtx *find_split_point (rtx *, rtx);
+static rtx subst (rtx, rtx, rtx, int, int);
+static rtx combine_simplify_rtx (rtx, enum machine_mode, int, int);
+static rtx simplify_if_then_else (rtx);
+static rtx simplify_set (rtx);
+static rtx simplify_logical (rtx, int);
+static rtx expand_compound_operation (rtx);
+static rtx expand_field_assignment (rtx);
+static rtx make_extraction (enum machine_mode, rtx, HOST_WIDE_INT,
+ rtx, unsigned HOST_WIDE_INT, int, int, int);
+static rtx extract_left_shift (rtx, int);
+static rtx make_compound_operation (rtx, enum rtx_code);
+static int get_pos_from_mask (unsigned HOST_WIDE_INT,
+ unsigned HOST_WIDE_INT *);
+static rtx force_to_mode (rtx, enum machine_mode,
+ unsigned HOST_WIDE_INT, rtx, int);
+static rtx if_then_else_cond (rtx, rtx *, rtx *);
+static rtx known_cond (rtx, enum rtx_code, rtx, rtx);
+static int rtx_equal_for_field_assignment_p (rtx, rtx);
+static rtx make_field_assignment (rtx);
+static rtx apply_distributive_law (rtx);
+static rtx simplify_and_const_int (rtx, enum machine_mode, rtx,
+ unsigned HOST_WIDE_INT);
+static unsigned HOST_WIDE_INT cached_nonzero_bits (rtx, enum machine_mode,
+ rtx, enum machine_mode,
+ unsigned HOST_WIDE_INT);
+static unsigned HOST_WIDE_INT nonzero_bits1 (rtx, enum machine_mode, rtx,
+ enum machine_mode,
+ unsigned HOST_WIDE_INT);
+static unsigned int cached_num_sign_bit_copies (rtx, enum machine_mode, rtx,
+ enum machine_mode,
+ unsigned int);
+static unsigned int num_sign_bit_copies1 (rtx, enum machine_mode, rtx,
+ enum machine_mode, unsigned int);
+static int merge_outer_ops (enum rtx_code *, HOST_WIDE_INT *, enum rtx_code,
+ HOST_WIDE_INT, enum machine_mode, int *);
+static rtx simplify_shift_const (rtx, enum rtx_code, enum machine_mode, rtx,
+ int);
+static int recog_for_combine (rtx *, rtx, rtx *);
+static rtx gen_lowpart_for_combine (enum machine_mode, rtx);
+static rtx gen_binary (enum rtx_code, enum machine_mode, rtx, rtx);
+static enum rtx_code simplify_comparison (enum rtx_code, rtx *, rtx *);
+static void update_table_tick (rtx);
+static void record_value_for_reg (rtx, rtx, rtx);
+static void check_promoted_subreg (rtx, rtx);
+static void record_dead_and_set_regs_1 (rtx, rtx, void *);
+static void record_dead_and_set_regs (rtx);
+static int get_last_value_validate (rtx *, rtx, int, int);
+static rtx get_last_value (rtx);
+static int use_crosses_set_p (rtx, int);
+static void reg_dead_at_p_1 (rtx, rtx, void *);
+static int reg_dead_at_p (rtx, rtx);
+static void move_deaths (rtx, rtx, int, rtx, rtx *);
+static int reg_bitfield_target_p (rtx, rtx);
+static void distribute_notes (rtx, rtx, rtx, rtx);
+static void distribute_links (rtx);
+static void mark_used_regs_combine (rtx);
+static int insn_cuid (rtx);
+static void record_promoted_value (rtx, rtx);
+static rtx reversed_comparison (rtx, enum machine_mode, rtx, rtx);
+static enum rtx_code combine_reversed_comparison_code (rtx);
\f
/* Substitute NEWVAL, an rtx expression, into INTO, a place in some
insn. The substitution can be undone by undo_all. If INTO is already
the undo table. */
static void
-do_SUBST (into, newval)
- rtx *into, newval;
+do_SUBST (rtx *into, rtx newval)
{
struct undo *buf;
rtx oldval = *into;
not safe. */
static void
-do_SUBST_INT (into, newval)
- int *into, newval;
+do_SUBST_INT (int *into, int newval)
{
struct undo *buf;
int oldval = *into;
Return nonzero if the combiner has turned an indirect jump
instruction into a direct jump. */
int
-combine_instructions (f, nregs)
- rtx f;
- unsigned int nregs;
+combine_instructions (rtx f, unsigned int nregs)
{
rtx insn, next;
#ifdef HAVE_cc0
/* Wipe the reg_last_xxx arrays in preparation for another pass. */
static void
-init_reg_last_arrays ()
+init_reg_last_arrays (void)
{
unsigned int nregs = combine_max_regno;
/* Set up any promoted values for incoming argument registers. */
static void
-setup_incoming_promotions ()
+setup_incoming_promotions (void)
{
#ifdef PROMOTE_FUNCTION_ARGS
unsigned int regno;
by any set of X. */
static void
-set_nonzero_bits_and_sign_copies (x, set, data)
- rtx x;
- rtx set;
- void *data ATTRIBUTE_UNUSED;
+set_nonzero_bits_and_sign_copies (rtx x, rtx set,
+ void *data ATTRIBUTE_UNUSED)
{
unsigned int num;
will return 1. */
static int
-can_combine_p (insn, i3, pred, succ, pdest, psrc)
- rtx insn;
- rtx i3;
- rtx pred ATTRIBUTE_UNUSED;
- rtx succ;
- rtx *pdest, *psrc;
+can_combine_p (rtx insn, rtx i3, rtx pred ATTRIBUTE_UNUSED, rtx succ,
+ rtx *pdest, rtx *psrc)
{
int i;
rtx set = 0, src, dest;
argument for a function in a hard register. */
static int
-sets_function_arg_p (pat)
- rtx pat;
+sets_function_arg_p (rtx pat)
{
int i;
rtx inner_dest;
Return 1 if the combination is valid, zero otherwise. */
static int
-combinable_i3pat (i3, loc, i2dest, i1dest, i1_not_in_src, pi3dest_killed)
- rtx i3;
- rtx *loc;
- rtx i2dest;
- rtx i1dest;
- int i1_not_in_src;
- rtx *pi3dest_killed;
+combinable_i3pat (rtx i3, rtx *loc, rtx i2dest, rtx i1dest,
+ int i1_not_in_src, rtx *pi3dest_killed)
{
rtx x = *loc;
and division. We don't count multiplications by powers of two here. */
static int
-contains_muldiv (x)
- rtx x;
+contains_muldiv (rtx x)
{
switch (GET_CODE (x))
{
can't perform combinations. */
static int
-cant_combine_insn_p (insn)
- rtx insn;
+cant_combine_insn_p (rtx insn)
{
rtx set;
rtx src, dest;
new direct jump instruction. */
static rtx
-try_combine (i3, i2, i1, new_direct_jump_p)
- rtx i3, i2, i1;
- int *new_direct_jump_p;
+try_combine (rtx i3, rtx i2, rtx i1, int *new_direct_jump_p)
{
/* New patterns for I3 and I2, respectively. */
rtx newpat, newi2pat = 0;
/* Undo all the modifications recorded in undobuf. */
static void
-undo_all ()
+undo_all (void)
{
struct undo *undo, *next;
of the undos to the free list. */
static void
-undo_commit ()
+undo_commit (void)
{
struct undo *undo, *next;
two insns. */
static rtx *
-find_split_point (loc, insn)
- rtx *loc;
- rtx insn;
+find_split_point (rtx *loc, rtx insn)
{
rtx x = *loc;
enum rtx_code code = GET_CODE (x);
by copying if `n_occurrences' is nonzero. */
static rtx
-subst (x, from, to, in_dest, unique_copy)
- rtx x, from, to;
- int in_dest;
- int unique_copy;
+subst (rtx x, rtx from, rtx to, int in_dest, int unique_copy)
{
enum rtx_code code = GET_CODE (x);
enum machine_mode op0_mode = VOIDmode;
X is returned; IN_DEST is nonzero if we are inside a SET_DEST. */
static rtx
-combine_simplify_rtx (x, op0_mode, last, in_dest)
- rtx x;
- enum machine_mode op0_mode;
- int last;
- int in_dest;
+combine_simplify_rtx (rtx x, enum machine_mode op0_mode, int last,
+ int in_dest)
{
enum rtx_code code = GET_CODE (x);
enum machine_mode mode = GET_MODE (x);
x = gen_binary (cond_code, mode, cond, cop1);
else if (true_rtx == const0_rtx && false_rtx == const_true_rtx
&& ((reversed = reversed_comparison_code_parts
- (cond_code, cond, cop1, NULL))
+ (cond_code, cond, cop1, NULL))
!= UNKNOWN))
x = gen_binary (reversed, mode, cond, cop1);
&& INTVAL (false_rtx) == - STORE_FLAG_VALUE
&& true_rtx == const0_rtx
&& ((reversed = reversed_comparison_code_parts
- (cond_code, cond, cop1, NULL))
+ (cond_code, cond, cop1, NULL))
!= UNKNOWN))
x = simplify_gen_unary (NEG, mode,
gen_binary (reversed, mode,
- cond, cop1),
+ cond, cop1),
mode);
else
return gen_rtx_IF_THEN_ELSE (mode,
&& flag_unsafe_math_optimizations)
|| GET_CODE (XEXP (x, 0)) == FLOAT_EXTEND)
return simplify_gen_unary (GET_MODE_SIZE (GET_MODE (XEXP (XEXP (x, 0),
- 0)))
- > GET_MODE_SIZE (mode)
+ 0)))
+ > GET_MODE_SIZE (mode)
? FLOAT_TRUNCATE : FLOAT_EXTEND,
- mode,
+ mode,
XEXP (XEXP (x, 0), 0), mode);
/* (float_truncate (float x)) is (float x) */
/* Simplify X, an IF_THEN_ELSE expression. Return the new expression. */
static rtx
-simplify_if_then_else (x)
- rtx x;
+simplify_if_then_else (rtx x)
{
enum machine_mode mode = GET_MODE (x);
rtx cond = XEXP (x, 0);
/* Simplify X, a SET expression. Return the new expression. */
static rtx
-simplify_set (x)
- rtx x;
+simplify_set (rtx x)
{
rtx src = SET_SRC (x);
rtx dest = SET_DEST (x);
result. LAST is nonzero if this is the last retry. */
static rtx
-simplify_logical (x, last)
- rtx x;
- int last;
+simplify_logical (rtx x, int last)
{
enum machine_mode mode = GET_MODE (x);
rtx op0 = XEXP (x, 0);
It is the inverse of this function, loosely speaking. */
static rtx
-expand_compound_operation (x)
- rtx x;
+expand_compound_operation (rtx x)
{
unsigned HOST_WIDE_INT pos = 0, len;
int unsignedp = 0;
support variable lengths. */
static rtx
-expand_field_assignment (x)
- rtx x;
+expand_field_assignment (rtx x)
{
rtx inner;
rtx pos; /* Always counts from low bit. */
can't handle it. */
static rtx
-make_extraction (mode, inner, pos, pos_rtx, len,
- unsignedp, in_dest, in_compare)
- enum machine_mode mode;
- rtx inner;
- HOST_WIDE_INT pos;
- rtx pos_rtx;
- unsigned HOST_WIDE_INT len;
- int unsignedp;
- int in_dest, in_compare;
+make_extraction (enum machine_mode mode, rtx inner, HOST_WIDE_INT pos,
+ rtx pos_rtx, unsigned HOST_WIDE_INT len, int unsignedp,
+ int in_dest, int in_compare)
{
/* This mode describes the size of the storage area
to fetch the overall value from. Within that, we
with any other operations in X. Return X without that shift if so. */
static rtx
-extract_left_shift (x, count)
- rtx x;
- int count;
+extract_left_shift (rtx x, int count)
{
enum rtx_code code = GET_CODE (x);
enum machine_mode mode = GET_MODE (x);
or a COMPARE against zero, it is COMPARE. */
static rtx
-make_compound_operation (x, in_code)
- rtx x;
- enum rtx_code in_code;
+make_compound_operation (rtx x, enum rtx_code in_code)
{
enum rtx_code code = GET_CODE (x);
enum machine_mode mode = GET_MODE (x);
*PLEN is set to the length of the field. */
static int
-get_pos_from_mask (m, plen)
- unsigned HOST_WIDE_INT m;
- unsigned HOST_WIDE_INT *plen;
+get_pos_from_mask (unsigned HOST_WIDE_INT m, unsigned HOST_WIDE_INT *plen)
{
/* Get the bit number of the first 1 bit from the right, -1 if none. */
int pos = exact_log2 (m & -m);
NOT, NEG, or XOR. */
static rtx
-force_to_mode (x, mode, mask, reg, just_select)
- rtx x;
- enum machine_mode mode;
- unsigned HOST_WIDE_INT mask;
- rtx reg;
- int just_select;
+force_to_mode (rtx x, enum machine_mode mode, unsigned HOST_WIDE_INT mask,
+ rtx reg, int just_select)
{
enum rtx_code code = GET_CODE (x);
int next_select = just_select || code == XOR || code == NOT || code == NEG;
If we return zero, we set *PTRUE and *PFALSE to X. */
static rtx
-if_then_else_cond (x, ptrue, pfalse)
- rtx x;
- rtx *ptrue, *pfalse;
+if_then_else_cond (rtx x, rtx *ptrue, rtx *pfalse)
{
enum machine_mode mode = GET_MODE (x);
enum rtx_code code = GET_CODE (x);
arise with IF_THEN_ELSE expressions. */
static rtx
-known_cond (x, cond, reg, val)
- rtx x;
- enum rtx_code cond;
- rtx reg, val;
+known_cond (rtx x, enum rtx_code cond, rtx reg, rtx val)
{
enum rtx_code code = GET_CODE (x);
rtx temp;
assignment as a field assignment. */
static int
-rtx_equal_for_field_assignment_p (x, y)
- rtx x;
- rtx y;
+rtx_equal_for_field_assignment_p (rtx x, rtx y)
{
if (x == y || rtx_equal_p (x, y))
return 1;
We only handle the most common cases. */
static rtx
-make_field_assignment (x)
- rtx x;
+make_field_assignment (rtx x)
{
rtx dest = SET_DEST (x);
rtx src = SET_SRC (x);
if so. */
static rtx
-apply_distributive_law (x)
- rtx x;
+apply_distributive_law (rtx x)
{
enum rtx_code code = GET_CODE (x);
rtx lhs, rhs, other;
X is zero, we are to always construct the equivalent form. */
static rtx
-simplify_and_const_int (x, mode, varop, constop)
- rtx x;
- enum machine_mode mode;
- rtx varop;
- unsigned HOST_WIDE_INT constop;
+simplify_and_const_int (rtx x, enum machine_mode mode, rtx varop,
+ unsigned HOST_WIDE_INT constop)
{
unsigned HOST_WIDE_INT nonzero;
int i;
identical subexpressions on the first or the second level. */
static unsigned HOST_WIDE_INT
-cached_nonzero_bits (x, mode, known_x, known_mode, known_ret)
- rtx x;
- enum machine_mode mode;
- rtx known_x;
- enum machine_mode known_mode;
- unsigned HOST_WIDE_INT known_ret;
+cached_nonzero_bits (rtx x, enum machine_mode mode, rtx known_x,
+ enum machine_mode known_mode,
+ unsigned HOST_WIDE_INT known_ret)
{
if (x == known_x && mode == known_mode)
return known_ret;
a shift, AND, or zero_extract, we can do better. */
static unsigned HOST_WIDE_INT
-nonzero_bits1 (x, mode, known_x, known_mode, known_ret)
- rtx x;
- enum machine_mode mode;
- rtx known_x;
- enum machine_mode known_mode;
- unsigned HOST_WIDE_INT known_ret;
+nonzero_bits1 (rtx x, enum machine_mode mode, rtx known_x,
+ enum machine_mode known_mode,
+ unsigned HOST_WIDE_INT known_ret)
{
unsigned HOST_WIDE_INT nonzero = GET_MODE_MASK (mode);
unsigned HOST_WIDE_INT inner_nz;
first or the second level. */
static unsigned int
-cached_num_sign_bit_copies (x, mode, known_x, known_mode, known_ret)
- rtx x;
- enum machine_mode mode;
- rtx known_x;
- enum machine_mode known_mode;
- unsigned int known_ret;
+cached_num_sign_bit_copies (rtx x, enum machine_mode mode, rtx known_x,
+ enum machine_mode known_mode,
+ unsigned int known_ret)
{
if (x == known_x && mode == known_mode)
return known_ret;
be between 1 and the number of bits in MODE. */
static unsigned int
-num_sign_bit_copies1 (x, mode, known_x, known_mode, known_ret)
- rtx x;
- enum machine_mode mode;
- rtx known_x;
- enum machine_mode known_mode;
- unsigned int known_ret;
+num_sign_bit_copies1 (rtx x, enum machine_mode mode, rtx known_x,
+ enum machine_mode known_mode,
+ unsigned int known_ret)
{
enum rtx_code code = GET_CODE (x);
unsigned int bitwidth;
implies that it must be called from a define_split. */
unsigned int
-extended_count (x, mode, unsignedp)
- rtx x;
- enum machine_mode mode;
- int unsignedp;
+extended_count (rtx x, enum machine_mode mode, int unsignedp)
{
if (nonzero_sign_valid == 0)
return 0;
return 0 and do not change *POP0, *PCONST0, and *PCOMP_P. */
static int
-merge_outer_ops (pop0, pconst0, op1, const1, mode, pcomp_p)
- enum rtx_code *pop0;
- HOST_WIDE_INT *pconst0;
- enum rtx_code op1;
- HOST_WIDE_INT const1;
- enum machine_mode mode;
- int *pcomp_p;
+merge_outer_ops (enum rtx_code *pop0, HOST_WIDE_INT *pconst0, enum rtx_code op1, HOST_WIDE_INT const1, enum machine_mode mode, int *pcomp_p)
{
enum rtx_code op0 = *pop0;
HOST_WIDE_INT const0 = *pconst0;
are ASHIFTRT and ROTATE, which are always done in their original mode, */
static rtx
-simplify_shift_const (x, code, result_mode, varop, orig_count)
- rtx x;
- enum rtx_code code;
- enum machine_mode result_mode;
- rtx varop;
- int orig_count;
+simplify_shift_const (rtx x, enum rtx_code code,
+ enum machine_mode result_mode, rtx varop,
+ int orig_count)
{
enum rtx_code orig_code = code;
unsigned int count;
or -1. */
static int
-recog_for_combine (pnewpat, insn, pnotes)
- rtx *pnewpat;
- rtx insn;
- rtx *pnotes;
+recog_for_combine (rtx *pnewpat, rtx insn, rtx *pnotes)
{
rtx pat = *pnewpat;
int insn_code_number;
#undef gen_lowpart
static rtx
-gen_lowpart_for_combine (mode, x)
- enum machine_mode mode;
- rtx x;
+gen_lowpart_for_combine (enum machine_mode mode, rtx x)
{
rtx result;
fold; if not, a new expression is allocated. */
static rtx
-gen_binary (code, mode, op0, op1)
- enum rtx_code code;
- enum machine_mode mode;
- rtx op0, op1;
+gen_binary (enum rtx_code code, enum machine_mode mode, rtx op0, rtx op1)
{
rtx result;
rtx tem;
should have been detected earlier. Hence we ignore all such cases. */
static enum rtx_code
-simplify_comparison (code, pop0, pop1)
- enum rtx_code code;
- rtx *pop0;
- rtx *pop1;
+simplify_comparison (enum rtx_code code, rtx *pop0, rtx *pop1)
{
rtx op0 = *pop0;
rtx op1 = *pop1;
/* Like jump.c' reversed_comparison_code, but use combine infrastructure for
searching backward. */
static enum rtx_code
-combine_reversed_comparison_code (exp)
- rtx exp;
+combine_reversed_comparison_code (rtx exp)
{
enum rtx_code code1 = reversed_comparison_code (exp, NULL);
rtx x;
/* Return comparison with reversed code of EXP and operands OP0 and OP1.
Return NULL_RTX in case we fail to do the reversal. */
static rtx
-reversed_comparison (exp, mode, op0, op1)
- rtx exp, op0, op1;
- enum machine_mode mode;
+reversed_comparison (rtx exp, enum machine_mode mode, rtx op0, rtx op1)
{
enum rtx_code reversed_code = combine_reversed_comparison_code (exp);
if (reversed_code == UNKNOWN)
for each register mentioned. Similar to mention_regs in cse.c */
static void
-update_table_tick (x)
- rtx x;
+update_table_tick (rtx x)
{
enum rtx_code code = GET_CODE (x);
const char *fmt = GET_RTX_FORMAT (code);
with VALUE also zero and is used to invalidate the register. */
static void
-record_value_for_reg (reg, insn, value)
- rtx reg;
- rtx insn;
- rtx value;
+record_value_for_reg (rtx reg, rtx insn, rtx value)
{
unsigned int regno = REGNO (reg);
unsigned int endregno
set is occurring. */
static void
-record_dead_and_set_regs_1 (dest, setter, data)
- rtx dest, setter;
- void *data;
+record_dead_and_set_regs_1 (rtx dest, rtx setter, void *data)
{
rtx record_dead_insn = (rtx) data;
subroutine call). */
static void
-record_dead_and_set_regs (insn)
- rtx insn;
+record_dead_and_set_regs (rtx insn)
{
rtx link;
unsigned int i;
missed because of that. */
static void
-record_promoted_value (insn, subreg)
- rtx insn;
- rtx subreg;
+record_promoted_value (rtx insn, rtx subreg)
{
rtx links, set;
unsigned int regno = REGNO (SUBREG_REG (subreg));
note what it implies to the registers used in it. */
static void
-check_promoted_subreg (insn, x)
- rtx insn;
- rtx x;
+check_promoted_subreg (rtx insn, rtx x)
{
if (GET_CODE (x) == SUBREG && SUBREG_PROMOTED_VAR_P (x)
&& GET_CODE (SUBREG_REG (x)) == REG)
we don't know exactly what registers it was produced from. */
static int
-get_last_value_validate (loc, insn, tick, replace)
- rtx *loc;
- rtx insn;
- int tick;
- int replace;
+get_last_value_validate (rtx *loc, rtx insn, int tick, int replace)
{
rtx x = *loc;
const char *fmt = GET_RTX_FORMAT (GET_CODE (x));
is known longer known reliably. */
static rtx
-get_last_value (x)
- rtx x;
+get_last_value (rtx x)
{
unsigned int regno;
rtx value;
that is set in an instruction more recent than FROM_CUID. */
static int
-use_crosses_set_p (x, from_cuid)
- rtx x;
- int from_cuid;
+use_crosses_set_p (rtx x, int from_cuid)
{
const char *fmt;
int i;
reg_dead_flag to 1 if X is a CLOBBER and to -1 it is a SET. */
static void
-reg_dead_at_p_1 (dest, x, data)
- rtx dest;
- rtx x;
- void *data ATTRIBUTE_UNUSED;
+reg_dead_at_p_1 (rtx dest, rtx x, void *data ATTRIBUTE_UNUSED)
{
unsigned int regno, endregno;
must be assumed to be always live. */
static int
-reg_dead_at_p (reg, insn)
- rtx reg;
- rtx insn;
+reg_dead_at_p (rtx reg, rtx insn)
{
basic_block block;
unsigned int i;
that in flow.c, but much simpler since we don't care about pseudos. */
static void
-mark_used_regs_combine (x)
- rtx x;
+mark_used_regs_combine (rtx x)
{
RTX_CODE code = GET_CODE (x);
unsigned int regno;
Return the note used to record the death, if there was one. */
rtx
-remove_death (regno, insn)
- unsigned int regno;
- rtx insn;
+remove_death (unsigned int regno, rtx insn)
{
rtx note = find_regno_note (insn, REG_DEAD, regno);
notes will then be distributed as needed. */
static void
-move_deaths (x, maybe_kill_insn, from_cuid, to_insn, pnotes)
- rtx x;
- rtx maybe_kill_insn;
- int from_cuid;
- rtx to_insn;
- rtx *pnotes;
+move_deaths (rtx x, rtx maybe_kill_insn, int from_cuid, rtx to_insn,
+ rtx *pnotes)
{
const char *fmt;
int len, i;
pattern of an insn. X must be a REG. */
static int
-reg_bitfield_target_p (x, body)
- rtx x;
- rtx body;
+reg_bitfield_target_p (rtx x, rtx body)
{
int i;
on the type of note. */
static void
-distribute_notes (notes, from_insn, i3, i2)
- rtx notes;
- rtx from_insn;
- rtx i3, i2;
+distribute_notes (rtx notes, rtx from_insn, rtx i3, rtx i2)
{
rtx note, next_note;
rtx tem;
add a link pointing at I3 when I3's destination is changed. */
static void
-distribute_links (links)
- rtx links;
+distribute_links (rtx links)
{
rtx link, next_link;
/* Compute INSN_CUID for INSN, which is an insn made by combine. */
static int
-insn_cuid (insn)
- rtx insn;
+insn_cuid (rtx insn)
{
while (insn != 0 && INSN_UID (insn) > max_uid_cuid
&& GET_CODE (insn) == INSN && GET_CODE (PATTERN (insn)) == USE)
}
\f
void
-dump_combine_stats (file)
- FILE *file;
+dump_combine_stats (FILE *file)
{
fnotice
(file,
}
void
-dump_combine_total_stats (file)
- FILE *file;
+dump_combine_total_stats (FILE *file)
{
fnotice
(file,
#define prefix_was_emitted_for(BUFFER) (BUFFER)->state.emitted_prefix_p
/* Prototypes. */
-static void output_flush PARAMS ((output_buffer *));
-static void output_do_verbatim PARAMS ((output_buffer *, text_info *));
-static void output_buffer_to_stream PARAMS ((output_buffer *));
-static void output_format PARAMS ((output_buffer *, text_info *));
-static void output_indent PARAMS ((output_buffer *));
+static void output_flush (output_buffer *);
+static void output_do_verbatim (output_buffer *, text_info *);
+static void output_buffer_to_stream (output_buffer *);
+static void output_format (output_buffer *, text_info *);
+static void output_indent (output_buffer *);
-static char *build_message_string PARAMS ((const char *, ...))
+static char *build_message_string (const char *, ...)
ATTRIBUTE_PRINTF_1;
-static void format_with_decl PARAMS ((output_buffer *, text_info *, tree));
-static void diagnostic_for_decl PARAMS ((diagnostic_context *,
- diagnostic_info *, tree));
-static void set_real_maximum_length PARAMS ((output_buffer *));
-
-static void output_unsigned_decimal PARAMS ((output_buffer *, unsigned int));
-static void output_long_decimal PARAMS ((output_buffer *, long int));
-static void output_long_unsigned_decimal PARAMS ((output_buffer *,
- long unsigned int));
-static void output_octal PARAMS ((output_buffer *, unsigned int));
-static void output_long_octal PARAMS ((output_buffer *, unsigned long int));
-static void output_hexadecimal PARAMS ((output_buffer *, unsigned int));
-static void output_long_hexadecimal PARAMS ((output_buffer *,
- unsigned long int));
-static void output_append_r PARAMS ((output_buffer *, const char *, int));
-static void wrap_text PARAMS ((output_buffer *, const char *, const char *));
-static void maybe_wrap_text PARAMS ((output_buffer *, const char *,
- const char *));
-static void output_clear_data PARAMS ((output_buffer *));
-
-static void default_diagnostic_starter PARAMS ((diagnostic_context *,
- diagnostic_info *));
-static void default_diagnostic_finalizer PARAMS ((diagnostic_context *,
- diagnostic_info *));
-
-static void error_recursion PARAMS ((diagnostic_context *)) ATTRIBUTE_NORETURN;
-static bool text_specifies_location PARAMS ((text_info *, location_t *));
-static bool diagnostic_count_diagnostic PARAMS ((diagnostic_context *,
- diagnostic_info *));
-static void diagnostic_action_after_output PARAMS ((diagnostic_context *,
- diagnostic_info *));
-static void real_abort PARAMS ((void)) ATTRIBUTE_NORETURN;
+static void format_with_decl (output_buffer *, text_info *, tree);
+static void diagnostic_for_decl (diagnostic_context *, diagnostic_info *,
+ tree);
+static void set_real_maximum_length (output_buffer *);
+
+static void output_unsigned_decimal (output_buffer *, unsigned int);
+static void output_long_decimal (output_buffer *, long int);
+static void output_long_unsigned_decimal (output_buffer *,
+ long unsigned int);
+static void output_octal (output_buffer *, unsigned int);
+static void output_long_octal (output_buffer *, unsigned long int);
+static void output_hexadecimal (output_buffer *, unsigned int);
+static void output_long_hexadecimal (output_buffer *, unsigned long int);
+static void output_append_r (output_buffer *, const char *, int);
+static void wrap_text (output_buffer *, const char *, const char *);
+static void maybe_wrap_text (output_buffer *, const char *, const char *);
+static void output_clear_data (output_buffer *);
+
+static void default_diagnostic_starter (diagnostic_context *,
+ diagnostic_info *);
+static void default_diagnostic_finalizer (diagnostic_context *,
+ diagnostic_info *);
+
+static void error_recursion (diagnostic_context *) ATTRIBUTE_NORETURN;
+static bool text_specifies_location (text_info *, location_t *);
+static bool diagnostic_count_diagnostic (diagnostic_context *,
+ diagnostic_info *);
+static void diagnostic_action_after_output (diagnostic_context *,
+ diagnostic_info *);
+static void real_abort (void) ATTRIBUTE_NORETURN;
extern int rtl_dump_and_exit;
extern int warnings_are_errors;
/* Subroutine of output_set_maximum_length. Set up BUFFER's
internal maximum characters per line. */
static void
-set_real_maximum_length (buffer)
- output_buffer *buffer;
+set_real_maximum_length (output_buffer *buffer)
{
/* If we're told not to wrap lines then do the obvious thing. In case
we'll emit prefix only once per diagnostic message, it is appropriate
/* Sets the number of maximum characters per line BUFFER can output
in line-wrapping mode. A LENGTH value 0 suppresses line-wrapping. */
void
-output_set_maximum_length (buffer, length)
- output_buffer *buffer;
- int length;
+output_set_maximum_length (output_buffer *buffer, int length)
{
output_line_cutoff (buffer) = length;
set_real_maximum_length (buffer);
/* Sets BUFFER's PREFIX. */
void
-output_set_prefix (buffer, prefix)
- output_buffer *buffer;
- const char *prefix;
+output_set_prefix (output_buffer *buffer, const char *prefix)
{
buffer->state.prefix = prefix;
set_real_maximum_length (buffer);
/* Return a pointer to the last character emitted in the output
BUFFER area. A NULL pointer means no character available. */
const char *
-output_last_position (buffer)
- const output_buffer *buffer;
+output_last_position (const output_buffer *buffer)
{
const char *p = NULL;
/* Free BUFFER's prefix, a previously malloc'd string. */
void
-output_destroy_prefix (buffer)
- output_buffer *buffer;
+output_destroy_prefix (output_buffer *buffer)
{
if (buffer->state.prefix != NULL)
{
/* Zero out any text output so far in BUFFER. */
void
-output_clear_message_text (buffer)
- output_buffer *buffer;
+output_clear_message_text (output_buffer *buffer)
{
obstack_free (&buffer->obstack, obstack_base (&buffer->obstack));
output_text_length (buffer) = 0;
/* Zero out any formatting data used so far by BUFFER. */
static void
-output_clear_data (buffer)
- output_buffer *buffer;
+output_clear_data (output_buffer *buffer)
{
prefix_was_emitted_for (buffer) = false;
output_indentation (buffer) = 0;
/* Construct an output BUFFER with PREFIX and of MAXIMUM_LENGTH
characters per line. */
void
-init_output_buffer (buffer, prefix, maximum_length)
- output_buffer *buffer;
- const char *prefix;
- int maximum_length;
+init_output_buffer (output_buffer *buffer, const char *prefix,
+ int maximum_length)
{
memset (buffer, 0, sizeof (output_buffer));
obstack_init (&buffer->obstack);
/* Reinitialize BUFFER. */
void
-output_clear (buffer)
- output_buffer *buffer;
+output_clear (output_buffer *buffer)
{
output_clear_message_text (buffer);
output_clear_data (buffer);
/* Finishes constructing a NULL-terminated character string representing
the BUFFERed message. */
const char *
-output_finalize_message (buffer)
- output_buffer *buffer;
+output_finalize_message (output_buffer *buffer)
{
obstack_1grow (&buffer->obstack, '\0');
return output_message_text (buffer);
/* Return the amount of characters BUFFER can accept to
make a full line. */
int
-output_space_left (buffer)
- const output_buffer *buffer;
+output_space_left (const output_buffer *buffer)
{
return line_wrap_cutoff (buffer) - output_text_length (buffer);
}
/* Write out BUFFER's prefix. */
void
-output_emit_prefix (buffer)
- output_buffer *buffer;
+output_emit_prefix (output_buffer *buffer)
{
if (buffer->state.prefix != NULL)
{
/* Have BUFFER start a new line. */
void
-output_add_newline (buffer)
- output_buffer *buffer;
+output_add_newline (output_buffer *buffer)
{
obstack_1grow (&buffer->obstack, '\n');
output_text_length (buffer) = 0;
/* Appends a character to BUFFER. */
void
-output_add_character (buffer, c)
- output_buffer *buffer;
- int c;
+output_add_character (output_buffer *buffer, int c)
{
if (output_is_line_wrapping (buffer) && output_space_left (buffer) <= 0)
output_add_newline (buffer);
/* Adds a space to BUFFER. */
void
-output_add_space (buffer)
- output_buffer *buffer;
+output_add_space (output_buffer *buffer)
{
if (output_is_line_wrapping (buffer) && output_space_left (buffer) <= 0)
{
/* These functions format an INTEGER into BUFFER as suggested by their
names. */
void
-output_decimal (buffer, i)
- output_buffer *buffer;
- int i;
+output_decimal (output_buffer *buffer, int i)
{
output_formatted_scalar (buffer, "%d", i);
}
/* Append to BUFFER a string specified by its STARTING character
and LENGTH. */
static void
-output_append_r (buffer, start, length)
- output_buffer *buffer;
- const char *start;
- int length;
+output_append_r (output_buffer *buffer, const char *start, int length)
{
obstack_grow (&buffer->obstack, start, length);
output_text_length (buffer) += length;
and skip any leading whitespace if appropriate. The caller must ensure
that it is safe to do so. */
void
-output_append (buffer, start, end)
- output_buffer *buffer;
- const char *start;
- const char *end;
+output_append (output_buffer *buffer, const char *start, const char *end)
{
/* Emit prefix and skip whitespace if we're starting a new line. */
if (is_starting_newline (buffer))
the current indentation level, assuming that a newline has just
been written to the buffer. */
static void
-output_indent (buffer)
- output_buffer *buffer;
+output_indent (output_buffer *buffer)
{
int n = output_indentation (buffer);
int i;
/* Wrap a text delimited by START and END into BUFFER. */
static void
-wrap_text (buffer, start, end)
- output_buffer *buffer;
- const char *start;
- const char *end;
+wrap_text (output_buffer *buffer, const char *start, const char *end)
{
bool is_wrapping = output_is_line_wrapping (buffer);
/* Same as wrap_text but wrap text only when in line-wrapping mode. */
static void
-maybe_wrap_text (buffer, start, end)
- output_buffer *buffer;
- const char *start;
- const char *end;
+maybe_wrap_text (output_buffer *buffer, const char *start, const char *end)
{
if (output_is_line_wrapping (buffer))
wrap_text (buffer, start, end);
/* Append a STRING to BUFFER; the STRING might be line-wrapped if in
appropriate mode. */
void
-output_add_string (buffer, str)
- output_buffer *buffer;
- const char *str;
+output_add_string (output_buffer *buffer, const char *str)
{
maybe_wrap_text (buffer, str, str + (str ? strlen (str) : 0));
}
/* Append an identifier ID to BUFFER. */
void
-output_add_identifier (buffer, id)
- output_buffer *buffer;
- tree id;
+output_add_identifier (output_buffer *buffer, tree id)
{
output_append (buffer, IDENTIFIER_POINTER (id),
IDENTIFIER_POINTER (id) + IDENTIFIER_LENGTH (id));
and reinitialize. */
static void
-output_buffer_to_stream (buffer)
- output_buffer *buffer;
+output_buffer_to_stream (output_buffer *buffer)
{
const char *text = output_finalize_message (buffer);
fputs (text, output_buffer_attached_stream (buffer));
%*.s: a substring the length of which is specified by an integer.
%H: location_t. */
static void
-output_format (buffer, text)
- output_buffer *buffer;
- text_info *text;
+output_format (output_buffer *buffer, text_info *text)
{
for (; *text->format_spec; ++text->format_spec)
{
/* Same as diagnostic_build_prefix, but only the source FILE is given. */
char *
-file_name_as_prefix (f)
- const char *f;
+file_name_as_prefix (const char *f)
{
return build_message_string ("%s: ", f);
}
/* Print a message relevant to the given DECL. */
static void
-format_with_decl (buffer, text, decl)
- output_buffer *buffer;
- text_info *text;
- tree decl;
+format_with_decl (output_buffer *buffer, text_info *text, tree decl)
{
const char *p;
/* Flush the content of BUFFER onto the attached stream. */
static void
-output_flush (buffer)
- output_buffer *buffer;
+output_flush (output_buffer *buffer)
{
output_buffer_to_stream (buffer);
output_clear_data (buffer);
/* Helper subroutine of output_verbatim and verbatim. Do the appropriate
settings needed by BUFFER for a verbatim formatting. */
static void
-output_do_verbatim (buffer, text)
- output_buffer *buffer;
- text_info *text;
+output_do_verbatim (output_buffer *buffer, text_info *text)
{
diagnostic_prefixing_rule_t rule = output_prefixing_rule (buffer);
int line_cutoff = output_line_cutoff (buffer);
\f
/* Initialize the diagnostic message outputting machinery. */
void
-diagnostic_initialize (context)
- diagnostic_context *context;
+diagnostic_initialize (diagnostic_context *context)
{
memset (context, 0, sizeof *context);
obstack_init (&context->buffer.obstack);
for a location_t. If so, update the object pointed by LOCUS to reflect
the specified location in *TEXT->args_ptr. */
static bool
-text_specifies_location (text, locus)
- text_info *text;
- location_t *locus;
+text_specifies_location (text_info *text, location_t *locus)
{
const char *p;
/* Skip any leading text. */
}
void
-diagnostic_set_info (diagnostic, msgid, args, file, line, kind)
- diagnostic_info *diagnostic;
- const char *msgid;
- va_list *args;
- const char *file;
- int line;
- diagnostic_t kind;
+diagnostic_set_info (diagnostic_info *diagnostic, const char *msgid,
+ va_list *args, const char *file, int line,
+ diagnostic_t kind)
{
diagnostic->message.err_no = errno;
diagnostic->message.args_ptr = args;
/* Return a malloc'd string describing a location. The caller is
responsible for freeing the memory. */
char *
-diagnostic_build_prefix (diagnostic)
- diagnostic_info *diagnostic;
+diagnostic_build_prefix (diagnostic_info *diagnostic)
{
static const char *const diagnostic_kind_text[] = {
#define DEFINE_DIAGNOSTIC_KIND(K, T) (T),
}
void
-diagnostic_flush_buffer (context)
- diagnostic_context *context;
+diagnostic_flush_buffer (diagnostic_context *context)
{
output_buffer_to_stream (&context->buffer);
fflush (output_buffer_attached_stream (&context->buffer));
/* Count a diagnostic. Return true if the message should be printed. */
static bool
-diagnostic_count_diagnostic (context, diagnostic)
- diagnostic_context *context;
- diagnostic_info *diagnostic;
+diagnostic_count_diagnostic (diagnostic_context *context,
+ diagnostic_info *diagnostic)
{
diagnostic_t kind = diagnostic->kind;
switch (kind)
/* Take any action which is expected to happen after the diagnostic
is written out. This function does not always return. */
static void
-diagnostic_action_after_output (context, diagnostic)
- diagnostic_context *context;
- diagnostic_info *diagnostic;
+diagnostic_action_after_output (diagnostic_context *context,
+ diagnostic_info *diagnostic)
{
switch (diagnostic->kind)
{
/* Called when the start of a function definition is parsed,
this function prints on stderr the name of the function. */
void
-announce_function (decl)
- tree decl;
+announce_function (tree decl)
{
if (!quiet_flag)
{
/* The default function to print out name of current function that caused
an error. */
void
-lhd_print_error_function (context, file)
- diagnostic_context *context;
- const char *file;
+lhd_print_error_function (diagnostic_context *context, const char *file)
{
if (diagnostic_last_function_changed (context))
{
We ignore the FILE parameter, as it cannot be relied upon. */
void
-diagnostic_report_current_function (context)
- diagnostic_context *context;
+diagnostic_report_current_function (diagnostic_context *context)
{
diagnostic_report_current_module (context);
(*lang_hooks.print_error_function) (context, input_filename);
}
void
-diagnostic_report_current_module (context)
- diagnostic_context *context;
+diagnostic_report_current_module (diagnostic_context *context)
{
struct file_stack *p;
}
static void
-default_diagnostic_starter (context, diagnostic)
- diagnostic_context *context;
- diagnostic_info *diagnostic;
+default_diagnostic_starter (diagnostic_context *context,
+ diagnostic_info *diagnostic)
{
diagnostic_report_current_function (context);
output_set_prefix (&context->buffer, diagnostic_build_prefix (diagnostic));
in the documentation of output_format. */
void
-diagnostic_report_diagnostic (context, diagnostic)
- diagnostic_context *context;
- diagnostic_info *diagnostic;
+diagnostic_report_diagnostic (diagnostic_context *context,
+ diagnostic_info *diagnostic)
{
if (context->lock++)
error_recursion (context);
MSG is a format string which uses %s to substitute the declaration
name; subsequent substitutions are a la output_format. */
static void
-diagnostic_for_decl (context, diagnostic, decl)
- diagnostic_context *context;
- diagnostic_info *diagnostic;
- tree decl;
+diagnostic_for_decl (diagnostic_context *context,
+ diagnostic_info *diagnostic, tree decl)
{
if (context->lock++)
error_recursion (context);
instead of `Internal compiler error in ../../GCC/gcc/expr.c'. */
const char *
-trim_filename (name)
- const char *name;
+trim_filename (const char *name)
{
static const char this_file[] = __FILE__;
const char *p = name, *q = this_file;
/* Warn about a use of an identifier which was marked deprecated. */
void
-warn_deprecated_use (node)
- tree node;
+warn_deprecated_use (tree node)
{
if (node == 0 || !warn_deprecated_decl)
return;
This mustn't use internal_error, that will cause infinite recursion. */
static void
-error_recursion (context)
- diagnostic_context *context;
+error_recursion (diagnostic_context *context)
{
if (context->lock < 3)
output_flush (&context->buffer);
code generally, thanks to a special macro. */
void
-fancy_abort (file, line, function)
- const char *file;
- int line;
- const char *function;
+fancy_abort (const char *file, int line, const char *function)
{
internal_error ("in %s, at %s:%d", function, trim_filename (file), line);
}
this file, so that there are no functions after it that call abort
and get the system abort instead of our macro. */
#undef abort
-static void
-real_abort ()
+static void
+real_abort (void)
{
abort ();
}
an output_buffer. A client-supplied formatter returns true if everything
goes well. */
typedef struct output_buffer output_buffer;
-typedef bool (*printer_fn) PARAMS ((output_buffer *, text_info *));
+typedef bool (*printer_fn) (output_buffer *, text_info *);
/* The output buffer datatype. This is best seen as an abstract datatype
whose fields should not be accessed directly by clients. */
/* Forward declarations. */
typedef struct diagnostic_context diagnostic_context;
-typedef void (*diagnostic_starter_fn) PARAMS ((diagnostic_context *,
- diagnostic_info *));
+typedef void (*diagnostic_starter_fn) (diagnostic_context *,
+ diagnostic_info *);
typedef diagnostic_starter_fn diagnostic_finalizer_fn;
/* This data structure bundles altogether any information relevant to
diagnostic_finalizer_fn end_diagnostic;
/* Client hook to report an internal error. */
- void (*internal_error) PARAMS ((const char *, va_list *));
+ void (*internal_error) (const char *, va_list *);
/* Function of last diagnostic message; more generally, function such that
if next diagnostic message is in it then we don't have to mention the
#define report_diagnostic(D) diagnostic_report_diagnostic (global_dc, D)
/* Diagnostic related functions. */
-extern void diagnostic_initialize PARAMS ((diagnostic_context *));
-extern void diagnostic_report_current_module PARAMS ((diagnostic_context *));
-extern void diagnostic_report_current_function PARAMS ((diagnostic_context *));
-extern void diagnostic_flush_buffer PARAMS ((diagnostic_context *));
-extern void diagnostic_report_diagnostic PARAMS ((diagnostic_context *,
- diagnostic_info *));
-extern void diagnostic_set_info PARAMS ((diagnostic_info *,
- const char *, va_list *,
- const char *, int,
- diagnostic_t));
-extern char *diagnostic_build_prefix PARAMS ((diagnostic_info *));
+extern void diagnostic_initialize (diagnostic_context *);
+extern void diagnostic_report_current_module (diagnostic_context *);
+extern void diagnostic_report_current_function (diagnostic_context *);
+extern void diagnostic_flush_buffer (diagnostic_context *);
+extern void diagnostic_report_diagnostic (diagnostic_context *,
+ diagnostic_info *);
+extern void diagnostic_set_info (diagnostic_info *, const char *, va_list *,
+ const char *, int, diagnostic_t);
+extern char *diagnostic_build_prefix (diagnostic_info *);
/* Pure text formatting support functions. */
-extern void init_output_buffer PARAMS ((output_buffer *,
- const char *, int));
-extern void output_clear PARAMS ((output_buffer *));
-extern const char *output_last_position PARAMS ((const output_buffer *));
-extern void output_set_prefix PARAMS ((output_buffer *,
- const char *));
-extern void output_destroy_prefix PARAMS ((output_buffer *));
-extern void output_set_maximum_length PARAMS ((output_buffer *, int));
-extern void output_emit_prefix PARAMS ((output_buffer *));
-extern void output_add_newline PARAMS ((output_buffer *));
-extern void output_add_space PARAMS ((output_buffer *));
-extern int output_space_left PARAMS ((const output_buffer *));
-extern void output_append PARAMS ((output_buffer *, const char *,
- const char *));
-extern void output_add_character PARAMS ((output_buffer *, int));
-extern void output_decimal PARAMS ((output_buffer *, int));
-extern void output_add_string PARAMS ((output_buffer *,
- const char *));
-extern void output_add_identifier PARAMS ((output_buffer *, tree));
-extern const char *output_finalize_message PARAMS ((output_buffer *));
-extern void output_clear_message_text PARAMS ((output_buffer *));
-extern void output_printf PARAMS ((output_buffer *, const char *,
- ...)) ATTRIBUTE_PRINTF_2;
+extern void init_output_buffer (output_buffer *, const char *, int);
+extern void output_clear (output_buffer *);
+extern const char *output_last_position (const output_buffer *);
+extern void output_set_prefix (output_buffer *, const char *);
+extern void output_destroy_prefix (output_buffer *);
+extern void output_set_maximum_length (output_buffer *, int);
+extern void output_emit_prefix (output_buffer *);
+extern void output_add_newline (output_buffer *);
+extern void output_add_space (output_buffer *);
+extern int output_space_left (const output_buffer *);
+extern void output_append (output_buffer *, const char *, const char *);
+extern void output_add_character (output_buffer *, int);
+extern void output_decimal (output_buffer *, int);
+extern void output_add_string (output_buffer *, const char *);
+extern void output_add_identifier (output_buffer *, tree);
+extern const char *output_finalize_message (output_buffer *);
+extern void output_clear_message_text (output_buffer *);
+extern void output_printf (output_buffer *, const char *, ...)
+ ATTRIBUTE_PRINTF_2;
extern void output_verbatim (output_buffer *, const char *, ...);
extern void verbatim (const char *, ...);
-extern char *file_name_as_prefix PARAMS ((const char *));
-extern void inform PARAMS ((const char *, ...));
+extern char *file_name_as_prefix (const char *);
+extern void inform (const char *, ...);
#endif /* ! GCC_DIAGNOSTIC_H */
#define PROB_VERY_LIKELY (REG_BR_PROB_BASE - PROB_VERY_UNLIKELY)
#define PROB_ALWAYS (REG_BR_PROB_BASE)
-static bool predicted_by_p PARAMS ((basic_block,
- enum br_predictor));
-static void combine_predictions_for_insn PARAMS ((rtx, basic_block));
-static void dump_prediction PARAMS ((enum br_predictor, int,
- basic_block, int));
-static void estimate_loops_at_level PARAMS ((struct loop *loop));
-static void propagate_freq PARAMS ((struct loop *));
-static void estimate_bb_frequencies PARAMS ((struct loops *));
-static void counts_to_freqs PARAMS ((void));
-static void process_note_predictions PARAMS ((basic_block, int *,
- dominance_info,
- dominance_info));
-static void process_note_prediction PARAMS ((basic_block, int *,
- dominance_info,
- dominance_info, int, int));
-static bool last_basic_block_p PARAMS ((basic_block));
-static void compute_function_frequency PARAMS ((void));
-static void choose_function_section PARAMS ((void));
-static bool can_predict_insn_p PARAMS ((rtx));
+static bool predicted_by_p (basic_block, enum br_predictor);
+static void combine_predictions_for_insn (rtx, basic_block);
+static void dump_prediction (enum br_predictor, int, basic_block, int);
+static void estimate_loops_at_level (struct loop *loop);
+static void propagate_freq (struct loop *);
+static void estimate_bb_frequencies (struct loops *);
+static void counts_to_freqs (void);
+static void process_note_predictions (basic_block, int *, dominance_info,
+ dominance_info);
+static void process_note_prediction (basic_block, int *, dominance_info,
+ dominance_info, int, int);
+static bool last_basic_block_p (basic_block);
+static void compute_function_frequency (void);
+static void choose_function_section (void);
+static bool can_predict_insn_p (rtx);
/* Information we hold about each branch predictor.
Filled using information from predict.def. */
for maximal performance. */
bool
-maybe_hot_bb_p (bb)
- basic_block bb;
+maybe_hot_bb_p (basic_block bb)
{
if (profile_info && flag_branch_probabilities
&& (bb->count
/* Return true in case BB is cold and should be optimized for size. */
bool
-probably_cold_bb_p (bb)
- basic_block bb;
+probably_cold_bb_p (basic_block bb)
{
if (profile_info && flag_branch_probabilities
&& (bb->count
/* Return true in case BB is probably never executed. */
bool
-probably_never_executed_bb_p (bb)
- basic_block bb;
+probably_never_executed_bb_p (basic_block bb)
{
if (profile_info && flag_branch_probabilities)
return ((bb->count + profile_info->runs / 2) / profile_info->runs) == 0;
PREDICTOR. */
static bool
-predicted_by_p (bb, predictor)
- basic_block bb;
- enum br_predictor predictor;
+predicted_by_p (basic_block bb, enum br_predictor predictor)
{
rtx note;
if (!INSN_P (bb->end))
}
void
-predict_insn (insn, predictor, probability)
- rtx insn;
- int probability;
- enum br_predictor predictor;
+predict_insn (rtx insn, enum br_predictor predictor, int probability)
{
if (!any_condjump_p (insn))
abort ();
/* Predict insn by given predictor. */
void
-predict_insn_def (insn, predictor, taken)
- rtx insn;
- enum br_predictor predictor;
- enum prediction taken;
+predict_insn_def (rtx insn, enum br_predictor predictor,
+ enum prediction taken)
{
int probability = predictor_info[(int) predictor].hitrate;
/* Predict edge E with given probability if possible. */
void
-predict_edge (e, predictor, probability)
- edge e;
- int probability;
- enum br_predictor predictor;
+predict_edge (edge e, enum br_predictor predictor, int probability)
{
rtx last_insn;
last_insn = e->src->end;
At the moment we represent predictions only on conditional
jumps, not at computed jump or other complicated cases. */
static bool
-can_predict_insn_p (insn)
- rtx insn;
+can_predict_insn_p (rtx insn)
{
return (GET_CODE (insn) == JUMP_INSN
&& any_condjump_p (insn)
/* Predict edge E by given predictor if possible. */
void
-predict_edge_def (e, predictor, taken)
- edge e;
- enum br_predictor predictor;
- enum prediction taken;
+predict_edge_def (edge e, enum br_predictor predictor,
+ enum prediction taken)
{
int probability = predictor_info[(int) predictor].hitrate;
to be done each time we invert the condition used by the jump. */
void
-invert_br_probabilities (insn)
- rtx insn;
+invert_br_probabilities (rtx insn)
{
rtx note;
/* Dump information about the branch prediction to the output file. */
static void
-dump_prediction (predictor, probability, bb, used)
- enum br_predictor predictor;
- int probability;
- basic_block bb;
- int used;
+dump_prediction (enum br_predictor predictor, int probability,
+ basic_block bb, int used)
{
edge e = bb->succ;
note if not already present. Remove now useless REG_BR_PRED notes. */
static void
-combine_predictions_for_insn (insn, bb)
- rtx insn;
- basic_block bb;
+combine_predictions_for_insn (rtx insn, basic_block bb)
{
rtx prob_note = find_reg_note (insn, REG_BR_PROB, 0);
rtx *pnote = ®_NOTES (insn);
predictions). */
void
-estimate_probability (loops_info)
- struct loops *loops_info;
+estimate_probability (struct loops *loops_info)
{
dominance_info dominators, post_dominators;
basic_block bb;
values. */
void
-expected_value_to_br_prob ()
+expected_value_to_br_prob (void)
{
rtx insn, cond, ev = NULL_RTX, ev_reg = NULL_RTX;
}
}
\f
-/* Check whether this is the last basic block of function. Commonly tehre
- is one extra common cleanup block. */
+/* Check whether this is the last basic block of function. Commonly
+ there is one extra common cleanup block. */
static bool
-last_basic_block_p (bb)
- basic_block bb;
+last_basic_block_p (basic_block bb)
{
if (bb == EXIT_BLOCK_PTR)
return false;
&& bb->succ->dest->next_bb == EXIT_BLOCK_PTR));
}
-/* Sets branch probabilities according to PREDiction and FLAGS. HEADS[bb->index]
- should be index of basic block in that we need to alter branch predictions
- (i.e. the first of our dominators such that we do not post-dominate it)
- (but we fill this information on demand, so -1 may be there in case this
- was not needed yet). */
+/* Sets branch probabilities according to PREDiction and
+ FLAGS. HEADS[bb->index] should be index of basic block in that we
+ need to alter branch predictions (i.e. the first of our dominators
+ such that we do not post-dominate it) (but we fill this information
+ on demand, so -1 may be there in case this was not needed yet). */
static void
-process_note_prediction (bb, heads, dominators, post_dominators, pred, flags)
- basic_block bb;
- int *heads;
- dominance_info dominators;
- dominance_info post_dominators;
- int pred;
- int flags;
+process_note_prediction (basic_block bb, int *heads,
+ dominance_info dominators,
+ dominance_info post_dominators, int pred,
+ int flags)
{
edge e;
int y;
process_note_prediction. */
static void
-process_note_predictions (bb, heads, dominators, post_dominators)
- basic_block bb;
- int *heads;
- dominance_info dominators;
- dominance_info post_dominators;
+process_note_predictions (basic_block bb, int *heads,
+ dominance_info dominators,
+ dominance_info post_dominators)
{
rtx insn;
edge e;
branch probabilities. */
void
-note_prediction_to_br_prob ()
+note_prediction_to_br_prob (void)
{
basic_block bb;
dominance_info post_dominators, dominators;
Propagate the frequencies for LOOP. */
static void
-propagate_freq (loop)
- struct loop *loop;
+propagate_freq (struct loop *loop)
{
basic_block head = loop->header;
basic_block bb;
sizeof (real_almost_one));
}
- /* BLOCK_INFO (bb)->frequency = frequency
+ /* BLOCK_INFO (bb)->frequency = frequency
/ (1 - cyclic_probability) */
sreal_sub (&cyclic_probability, &real_one, &cyclic_probability);
/* Estimate probabilities of loopback edges in loops at same nest level. */
static void
-estimate_loops_at_level (first_loop)
- struct loop *first_loop;
+estimate_loops_at_level (struct loop *first_loop)
{
struct loop *loop;
unsigned i;
estimate_loops_at_level (loop->inner);
-
+
if (loop->latch->succ) /* Do not do this for dummy function loop. */
{
/* Find current loop back edge and mark it. */
/* Convert counts measured by profile driven feedback to frequencies. */
static void
-counts_to_freqs ()
+counts_to_freqs (void)
{
gcov_type count_max = 1;
basic_block bb;
function can execute at average to be still considered not expensive. */
bool
-expensive_function_p (threshold)
- int threshold;
+expensive_function_p (int threshold)
{
unsigned int sum = 0;
basic_block bb;
/* Estimate basic blocks frequency by given branch probabilities. */
static void
-estimate_bb_frequencies (loops)
- struct loops *loops;
+estimate_bb_frequencies (struct loops *loops)
{
basic_block bb;
sreal freq_max;
/* Decide whether function is hot, cold or unlikely executed. */
static void
-compute_function_frequency ()
+compute_function_frequency (void)
{
basic_block bb;
/* Choose appropriate section for the function. */
static void
-choose_function_section ()
+choose_function_section (void)
{
if (DECL_SECTION_NAME (current_function_decl)
|| !targetm.have_named_sections
/* Theoretically we can split the gnu.linkonce text section too,
- but this requires more work as the frequency needs to match
+ but this requires more work as the frequency needs to match
for all generated objects so we need to merge the frequency
of all instances. For now just never set frequency for these. */
|| DECL_ONE_ONLY (current_function_decl))
/* This file contains the definitions and documentation for the
builtins used in the GNU compiler.
- Copyright (C) 2001 Free Software Foundation, Inc.
+ Copyright (C) 2001, 2003 Free Software Foundation, Inc.
This file is part of GCC.
/* Flags for NOTE_PREDICTION */
#define IS_TAKEN 1 /* Predict edges to the block as taken. */
-extern void predict_insn_def PARAMS ((rtx, enum br_predictor,
- enum prediction));
-extern void predict_insn PARAMS ((rtx, enum br_predictor, int));
+extern void predict_insn_def (rtx, enum br_predictor, enum prediction);
+extern void predict_insn (rtx, enum br_predictor, int);
/* Avoid unneeded dependency on basic_block.h */
#ifdef BASIC_BLOCK
-extern void predict_edge PARAMS ((edge, enum br_predictor, int));
-extern void predict_edge_def PARAMS ((edge, enum br_predictor,
- enum prediction));
+extern void predict_edge (edge, enum br_predictor, int);
+extern void predict_edge_def (edge, enum br_predictor, enum prediction);
#endif
extern void delete_insn_chain_and_edges PARAMS ((rtx, rtx));
/* In combine.c */
-extern int combine_instructions PARAMS ((rtx, unsigned int));
-extern unsigned int extended_count PARAMS ((rtx, enum machine_mode, int));
-extern rtx remove_death PARAMS ((unsigned int, rtx));
+extern int combine_instructions (rtx, unsigned int);
+extern unsigned int extended_count (rtx, enum machine_mode, int);
+extern rtx remove_death (unsigned int, rtx);
#ifdef BUFSIZ
-extern void dump_combine_stats PARAMS ((FILE *));
-extern void dump_combine_total_stats PARAMS ((FILE *));
+extern void dump_combine_stats (FILE *);
+extern void dump_combine_total_stats (FILE *);
#endif
/* In sched.c. */
#include "tree-dump.h"
#include "langhooks.h"
-static unsigned int queue PARAMS ((dump_info_p, tree, int));
-static void dump_index PARAMS ((dump_info_p, unsigned int));
-static void dequeue_and_dump PARAMS ((dump_info_p));
-static void dump_new_line PARAMS ((dump_info_p));
-static void dump_maybe_newline PARAMS ((dump_info_p));
-static void dump_string_field PARAMS ((dump_info_p, const char *, const char *));
+static unsigned int queue (dump_info_p, tree, int);
+static void dump_index (dump_info_p, unsigned int);
+static void dequeue_and_dump (dump_info_p);
+static void dump_new_line (dump_info_p);
+static void dump_maybe_newline (dump_info_p);
+static void dump_string_field (dump_info_p, const char *, const char *);
/* Add T to the end of the queue of nodes to dump. Returns the index
assigned to T. */
static unsigned int
-queue (di, t, flags)
- dump_info_p di;
- tree t;
- int flags;
+queue (dump_info_p di, tree t, int flags)
{
dump_queue_p dq;
dump_node_info_p dni;
}
static void
-dump_index (di, index)
- dump_info_p di;
- unsigned int index;
+dump_index (dump_info_p di, unsigned int index)
{
fprintf (di->stream, "@%-6u ", index);
di->column += 8;
index of T is printed. */
void
-queue_and_dump_index (di, field, t, flags)
- dump_info_p di;
- const char *field;
- tree t;
- int flags;
+queue_and_dump_index (dump_info_p di, const char *field, tree t, int flags)
{
unsigned int index;
splay_tree_node n;
/* Dump the type of T. */
void
-queue_and_dump_type (di, t)
- dump_info_p di;
- tree t;
+queue_and_dump_type (dump_info_p di, tree t)
{
queue_and_dump_index (di, "type", TREE_TYPE (t), DUMP_NONE);
}
place to start printing more fields. */
static void
-dump_new_line (di)
- dump_info_p di;
+dump_new_line (dump_info_p di)
{
fprintf (di->stream, "\n%*s", SOL_COLUMN, "");
di->column = SOL_COLUMN;
/* If necessary, insert a new line. */
static void
-dump_maybe_newline (di)
- dump_info_p di;
+dump_maybe_newline (dump_info_p di)
{
int extra;
/* Dump pointer PTR using FIELD to identify it. */
void
-dump_pointer (di, field, ptr)
- dump_info_p di;
- const char *field;
- void *ptr;
+dump_pointer (dump_info_p di, const char *field, void *ptr)
{
dump_maybe_newline (di);
fprintf (di->stream, "%-4s: %-8lx ", field, (long) ptr);
/* Dump integer I using FIELD to identify it. */
void
-dump_int (di, field, i)
- dump_info_p di;
- const char *field;
- int i;
+dump_int (dump_info_p di, const char *field, int i)
{
dump_maybe_newline (di);
fprintf (di->stream, "%-4s: %-7d ", field, i);
/* Dump the string S. */
void
-dump_string (di, string)
- dump_info_p di;
- const char *string;
+dump_string (dump_info_p di, const char *string)
{
dump_maybe_newline (di);
fprintf (di->stream, "%-13s ", string);
/* Dump the string field S. */
static void
-dump_string_field (di, field, string)
- dump_info_p di;
- const char *field;
- const char *string;
+dump_string_field (dump_info_p di, const char *field, const char *string)
{
dump_maybe_newline (di);
fprintf (di->stream, "%-4s: %-7s ", field, string);
/* Dump the next node in the queue. */
static void
-dequeue_and_dump (di)
- dump_info_p di;
+dequeue_and_dump (dump_info_p di)
{
dump_queue_p dq;
splay_tree_node stn;
tree bases = BINFO_BASETYPES (t);
unsigned n_bases = bases ? TREE_VEC_LENGTH (bases): 0;
tree accesses = BINFO_BASEACCESSES (t);
-
+
dump_child ("type", BINFO_TYPE (t));
if (TREE_VIA_VIRTUAL (t))
string = "priv";
else
abort ();
-
+
dump_string (di, string);
queue_and_dump_index (di, "binf", base, DUMP_BINFO);
}
-
+
goto done;
}
/* Return nonzero if FLAG has been specified for the dump, and NODE
is not the root node of the dump. */
-int dump_flag (di, flag, node)
- dump_info_p di;
- int flag;
- tree node;
+int dump_flag (dump_info_p di, int flag, tree node)
{
return (di->flags & flag) && (node != di->node);
}
/* Dump T, and all its children, on STREAM. */
void
-dump_node (t, flags, stream)
- tree t;
- int flags;
- FILE *stream;
+dump_node (tree t, int flags, FILE *stream)
{
struct dump_info di;
dump_queue_p dq;
Multiple calls will reopen and append to the dump file. */
FILE *
-dump_begin (phase, flag_ptr)
- enum tree_dump_index phase;
- int *flag_ptr;
+dump_begin (enum tree_dump_index phase, int *flag_ptr)
{
FILE *stream;
char *name;
/* Returns nonzero if tree dump PHASE is enabled. */
int
-dump_enabled_p (phase)
- enum tree_dump_index phase;
+dump_enabled_p (enum tree_dump_index phase)
{
return dump_files[phase].state;
}
/* Returns the switch name of PHASE. */
const char *
-dump_flag_name (phase)
- enum tree_dump_index phase;
+dump_flag_name (enum tree_dump_index phase)
{
return dump_files[phase].swtch;
}
dump_begin. */
void
-dump_end (phase, stream)
- enum tree_dump_index phase ATTRIBUTE_UNUSED;
- FILE *stream;
+dump_end (enum tree_dump_index phase ATTRIBUTE_UNUSED, FILE *stream)
{
fclose (stream);
}
relevant details in the dump_files array. */
int
-dump_switch_p (arg)
- const char *arg;
+dump_switch_p (const char *arg)
{
unsigned ix;
const char *option_value;
/* Tree-dumping functionality for intermediate representation.
- Copyright (C) 1999, 2000 Free Software Foundation, Inc.
+ Copyright (C) 1999, 2000, 2003 Free Software Foundation, Inc.
Written by Mark Mitchell <mark@codesourcery.com>
This file is part of GCC.
#define dump_child(field, child) \
queue_and_dump_index (di, field, child, DUMP_NONE)
-extern void dump_pointer
- PARAMS ((dump_info_p, const char *, void *));
-extern void dump_int
- PARAMS ((dump_info_p, const char *, int));
-extern void dump_string
- PARAMS ((dump_info_p, const char *));
-extern void dump_stmt
- PARAMS ((dump_info_p, tree));
-extern void dump_next_stmt
- PARAMS ((dump_info_p, tree));
-extern void queue_and_dump_index
- PARAMS ((dump_info_p, const char *, tree, int));
-extern void queue_and_dump_type
- PARAMS ((dump_info_p, tree));
+extern void dump_pointer (dump_info_p, const char *, void *);
+extern void dump_int (dump_info_p, const char *, int);
+extern void dump_string (dump_info_p, const char *);
+extern void dump_stmt (dump_info_p, tree);
+extern void dump_next_stmt (dump_info_p, tree);
+extern void queue_and_dump_index (dump_info_p, const char *, tree, int);
+extern void queue_and_dump_type (dump_info_p, tree);
#endif /* ! GCC_TREE_DUMP_H */
projects / gcc.git / commitdiff