#include "function.h"
#include "toplev.h"
-#ifndef REGISTER_MOVE_COST
-#define REGISTER_MOVE_COST(m, x, y) 2
-#endif
-
#ifndef REGNO_MODE_OK_FOR_BASE_P
#define REGNO_MODE_OK_FOR_BASE_P(REGNO, MODE) REGNO_OK_FOR_BASE_P (REGNO)
#endif
: (type)))
#ifdef HAVE_SECONDARY_RELOADS
-static int push_secondary_reload PARAMS ((int, rtx, int, int, enum reg_class,
- enum machine_mode, enum reload_type,
- enum insn_code *));
+static int push_secondary_reload (int, rtx, int, int, enum reg_class,
+ enum machine_mode, enum reload_type,
+ enum insn_code *);
#endif
-static enum reg_class find_valid_class PARAMS ((enum machine_mode, int,
- unsigned int));
-static int reload_inner_reg_of_subreg PARAMS ((rtx, enum machine_mode, int));
-static void push_replacement PARAMS ((rtx *, int, enum machine_mode));
-static void dup_replacements PARAMS ((rtx *, rtx *));
-static void combine_reloads PARAMS ((void));
-static int find_reusable_reload PARAMS ((rtx *, rtx, enum reg_class,
- enum reload_type, int, int));
-static rtx find_dummy_reload PARAMS ((rtx, rtx, rtx *, rtx *,
- enum machine_mode, enum machine_mode,
- enum reg_class, int, int));
-static int hard_reg_set_here_p PARAMS ((unsigned int, unsigned int, rtx));
-static struct decomposition decompose PARAMS ((rtx));
-static int immune_p PARAMS ((rtx, rtx, struct decomposition));
-static int alternative_allows_memconst PARAMS ((const char *, int));
-static rtx find_reloads_toplev PARAMS ((rtx, int, enum reload_type, int,
- int, rtx, int *));
-static rtx make_memloc PARAMS ((rtx, int));
-static int maybe_memory_address_p PARAMS ((enum machine_mode, rtx, rtx *));
-static int find_reloads_address PARAMS ((enum machine_mode, rtx *, rtx, rtx *,
- int, enum reload_type, int, rtx));
-static rtx subst_reg_equivs PARAMS ((rtx, rtx));
-static rtx subst_indexed_address PARAMS ((rtx));
-static void update_auto_inc_notes PARAMS ((rtx, int, int));
-static int find_reloads_address_1 PARAMS ((enum machine_mode, rtx, int, rtx *,
- int, enum reload_type,int, rtx));
-static void find_reloads_address_part PARAMS ((rtx, rtx *, enum reg_class,
- enum machine_mode, int,
- enum reload_type, int));
-static rtx find_reloads_subreg_address PARAMS ((rtx, int, int,
- enum reload_type, int, rtx));
-static void copy_replacements_1 PARAMS ((rtx *, rtx *, int));
-static int find_inc_amount PARAMS ((rtx, rtx));
+static enum reg_class find_valid_class (enum machine_mode, int, unsigned int);
+static int reload_inner_reg_of_subreg (rtx, enum machine_mode, int);
+static void push_replacement (rtx *, int, enum machine_mode);
+static void dup_replacements (rtx *, rtx *);
+static void combine_reloads (void);
+static int find_reusable_reload (rtx *, rtx, enum reg_class,
+ enum reload_type, int, int);
+static rtx find_dummy_reload (rtx, rtx, rtx *, rtx *, enum machine_mode,
+ enum machine_mode, enum reg_class, int, int);
+static int hard_reg_set_here_p (unsigned int, unsigned int, rtx);
+static struct decomposition decompose (rtx);
+static int immune_p (rtx, rtx, struct decomposition);
+static int alternative_allows_memconst (const char *, int);
+static rtx find_reloads_toplev (rtx, int, enum reload_type, int, int, rtx,
+ int *);
+static rtx make_memloc (rtx, int);
+static int maybe_memory_address_p (enum machine_mode, rtx, rtx *);
+static int find_reloads_address (enum machine_mode, rtx *, rtx, rtx *,
+ int, enum reload_type, int, rtx);
+static rtx subst_reg_equivs (rtx, rtx);
+static rtx subst_indexed_address (rtx);
+static void update_auto_inc_notes (rtx, int, int);
+static int find_reloads_address_1 (enum machine_mode, rtx, int, rtx *,
+ int, enum reload_type,int, rtx);
+static void find_reloads_address_part (rtx, rtx *, enum reg_class,
+ enum machine_mode, int,
+ enum reload_type, int);
+static rtx find_reloads_subreg_address (rtx, int, int, enum reload_type,
+ int, rtx);
+static void copy_replacements_1 (rtx *, rtx *, int);
+static int find_inc_amount (rtx, rtx);
\f
#ifdef HAVE_SECONDARY_RELOADS
need a secondary reload. */
static int
-push_secondary_reload (in_p, x, opnum, optional, reload_class, reload_mode,
- type, picode)
- int in_p;
- rtx x;
- int opnum;
- int optional;
- enum reg_class reload_class;
- enum machine_mode reload_mode;
- enum reload_type type;
- enum insn_code *picode;
+push_secondary_reload (int in_p, rtx x, int opnum, int optional,
+ enum reg_class reload_class,
+ enum machine_mode reload_mode, enum reload_type type,
+ enum insn_code *picode)
{
enum reg_class class = NO_REGS;
enum machine_mode mode = reload_mode;
call find_reloads_address on the location being returned. */
rtx
-get_secondary_mem (x, mode, opnum, type)
- rtx x ATTRIBUTE_UNUSED;
- enum machine_mode mode;
- int opnum;
- enum reload_type type;
+get_secondary_mem (rtx x ATTRIBUTE_UNUSED, enum machine_mode mode,
+ int opnum, enum reload_type type)
{
rtx loc;
int mem_valid;
/* Clear any secondary memory locations we've made. */
void
-clear_secondary_mem ()
+clear_secondary_mem (void)
{
- memset ((char *) secondary_memlocs, 0, sizeof secondary_memlocs);
+ memset (secondary_memlocs, 0, sizeof secondary_memlocs);
}
#endif /* SECONDARY_MEMORY_NEEDED */
\f
Abort if no such class exists. */
static enum reg_class
-find_valid_class (m1, n, dest_regno)
- enum machine_mode m1 ATTRIBUTE_UNUSED;
- int n;
- unsigned int dest_regno ATTRIBUTE_UNUSED;
+find_valid_class (enum machine_mode m1 ATTRIBUTE_UNUSED, int n,
+ unsigned int dest_regno ATTRIBUTE_UNUSED)
{
int best_cost = -1;
int class;
DONT_SHARE is nonzero if we can't share any input-only reload for IN. */
static int
-find_reusable_reload (p_in, out, class, type, opnum, dont_share)
- rtx *p_in, out;
- enum reg_class class;
- enum reload_type type;
- int opnum, dont_share;
+find_reusable_reload (rtx *p_in, rtx out, enum reg_class class,
+ enum reload_type type, int opnum, int dont_share)
{
rtx in = *p_in;
int i;
SUBREG_REG expression. */
static int
-reload_inner_reg_of_subreg (x, mode, output)
- rtx x;
- enum machine_mode mode;
- int output;
+reload_inner_reg_of_subreg (rtx x, enum machine_mode mode, int output)
{
rtx inner;
distinguish them. */
int
-push_reload (in, out, inloc, outloc, class,
- inmode, outmode, strict_low, optional, opnum, type)
- rtx in, out;
- rtx *inloc, *outloc;
- enum reg_class class;
- enum machine_mode inmode, outmode;
- int strict_low;
- int optional;
- int opnum;
- enum reload_type type;
+push_reload (rtx in, rtx out, rtx *inloc, rtx *outloc,
+ enum reg_class class, enum machine_mode inmode,
+ enum machine_mode outmode, int strict_low, int optional,
+ int opnum, enum reload_type type)
{
int i;
int dont_share = 0;
|| (GET_CODE (SUBREG_REG (out)) == REG
&& REGNO (SUBREG_REG (out)) < FIRST_PSEUDO_REGISTER
&& REG_CANNOT_CHANGE_MODE_P (REGNO (SUBREG_REG (out)),
- GET_MODE (SUBREG_REG (out)),
+ GET_MODE (SUBREG_REG (out)),
outmode))
#endif
))
This is used in insn patterns that use match_dup. */
static void
-push_replacement (loc, reloadnum, mode)
- rtx *loc;
- int reloadnum;
- enum machine_mode mode;
+push_replacement (rtx *loc, int reloadnum, enum machine_mode mode)
{
if (replace_reloads)
{
This is used in insn patterns that use match_dup. */
static void
-dup_replacements (dup_loc, orig_loc)
- rtx *dup_loc;
- rtx *orig_loc;
+dup_replacements (rtx *dup_loc, rtx *orig_loc)
{
int i, n = n_replacements;
reload TO. */
void
-transfer_replacements (to, from)
- int to, from;
+transfer_replacements (int to, int from)
{
int i;
cancel the reloads that were supposed to load them.
Return nonzero if we canceled any reloads. */
int
-remove_address_replacements (in_rtx)
- rtx in_rtx;
+remove_address_replacements (rtx in_rtx)
{
int i, j;
char reload_flags[MAX_RELOADS];
class and does not appear in the value being output-reloaded. */
static void
-combine_reloads ()
+combine_reloads (void)
{
int i;
int output_reload = -1;
is safe from the earlyclobber). */
static rtx
-find_dummy_reload (real_in, real_out, inloc, outloc,
- inmode, outmode, class, for_real, earlyclobber)
- rtx real_in, real_out;
- rtx *inloc, *outloc;
- enum machine_mode inmode, outmode;
- enum reg_class class;
- int for_real;
- int earlyclobber;
+find_dummy_reload (rtx real_in, rtx real_out, rtx *inloc, rtx *outloc,
+ enum machine_mode inmode, enum machine_mode outmode,
+ enum reg_class class, int for_real, int earlyclobber)
{
rtx in = real_in;
rtx out = real_out;
/* Return 1 if X is an operand of an insn that is being earlyclobbered. */
int
-earlyclobber_operand_p (x)
- rtx x;
+earlyclobber_operand_p (rtx x)
{
int i;
X should be the body of an instruction. */
static int
-hard_reg_set_here_p (beg_regno, end_regno, x)
- unsigned int beg_regno, end_regno;
- rtx x;
+hard_reg_set_here_p (unsigned int beg_regno, unsigned int end_regno, rtx x)
{
if (GET_CODE (x) == SET || GET_CODE (x) == CLOBBER)
{
hard reg. */
int
-strict_memory_address_p (mode, addr)
- enum machine_mode mode ATTRIBUTE_UNUSED;
- rtx addr;
+strict_memory_address_p (enum machine_mode mode ATTRIBUTE_UNUSED, rtx addr)
{
GO_IF_LEGITIMATE_ADDRESS (mode, addr, win);
return 0;
because that is natural in (SET output (... input ...)). */
int
-operands_match_p (x, y)
- rtx x, y;
+operands_match_p (rtx x, rtx y)
{
int i;
RTX_CODE code = GET_CODE (x);
so we set the SAFE field. */
static struct decomposition
-decompose (x)
- rtx x;
+decompose (rtx x)
{
struct decomposition val;
int all_const = 0;
Y is also described by YDATA, which should be decompose (Y). */
static int
-immune_p (x, y, ydata)
- rtx x, y;
- struct decomposition ydata;
+immune_p (rtx x, rtx y, struct decomposition ydata)
{
struct decomposition xdata;
/* Similar, but calls decompose. */
int
-safe_from_earlyclobber (op, clobber)
- rtx op, clobber;
+safe_from_earlyclobber (rtx op, rtx clobber)
{
struct decomposition early_data;
commutative operands, reg_equiv_address substitution, or whatever. */
int
-find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
- rtx insn;
- int replace, ind_levels;
- int live_known;
- short *reload_reg_p;
+find_reloads (rtx insn, int replace, int ind_levels, int live_known,
+ short *reload_reg_p)
{
int insn_code_number;
int i, j;
/* The eliminated forms of any secondary memory locations are per-insn, so
clear them out here. */
- memset ((char *) secondary_memlocs_elim, 0, sizeof secondary_memlocs_elim);
+ memset (secondary_memlocs_elim, 0, sizeof secondary_memlocs_elim);
#endif
/* Dispose quickly of (set (reg..) (reg..)) if both have hard regs and it
This is doubly true if WORD_REGISTER_OPERATIONS. In
this case eliminate_regs has left non-paradoxical
- subregs for push_reloads to see. Make sure it does
+ subregs for push_reload to see. Make sure it does
by forcing the reload.
??? When is it right at this stage to have a subreg
for (i = 0; i < n_reloads; i++)
if (rld[i].when_needed == RELOAD_FOR_INPUT
&& GET_CODE (PATTERN (insn)) == SET
- && GET_CODE (SET_DEST (PATTERN (insn))) == REG
- && SET_SRC (PATTERN (insn)) == rld[i].in)
+ && GET_CODE (SET_DEST (PATTERN (insn))) == REG
+ && SET_SRC (PATTERN (insn)) == rld[i].in)
{
- rtx dest = SET_DEST (PATTERN (insn));
+ rtx dest = SET_DEST (PATTERN (insn));
unsigned int regno = REGNO (dest);
- if (regno < FIRST_PSEUDO_REGISTER
- && TEST_HARD_REG_BIT (reg_class_contents[rld[i].class], regno)
- && HARD_REGNO_MODE_OK (regno, rld[i].mode))
+ if (regno < FIRST_PSEUDO_REGISTER
+ && TEST_HARD_REG_BIT (reg_class_contents[rld[i].class], regno)
+ && HARD_REGNO_MODE_OK (regno, rld[i].mode))
{
int nr = HARD_REGNO_NREGS (regno, rld[i].mode);
int ok = 1, nri;
accepts a memory operand with constant address. */
static int
-alternative_allows_memconst (constraint, altnum)
- const char *constraint;
- int altnum;
+alternative_allows_memconst (const char *constraint, int altnum)
{
int c;
/* Skip alternatives before the one requested. */
result of find_reloads_address. */
static rtx
-find_reloads_toplev (x, opnum, type, ind_levels, is_set_dest, insn,
- address_reloaded)
- rtx x;
- int opnum;
- enum reload_type type;
- int ind_levels;
- int is_set_dest;
- rtx insn;
- int *address_reloaded;
+find_reloads_toplev (rtx x, int opnum, enum reload_type type,
+ int ind_levels, int is_set_dest, rtx insn,
+ int *address_reloaded)
{
RTX_CODE code = GET_CODE (x);
This mem ref is not shared with anything. */
static rtx
-make_memloc (ad, regno)
- rtx ad;
- int regno;
+make_memloc (rtx ad, int regno)
{
/* We must rerun eliminate_regs, in case the elimination
offsets have changed. */
}
/* Returns true if AD could be turned into a valid memory reference
- to mode MODE by reloading the part pointed to by PART into a
+ to mode MODE by reloading the part pointed to by PART into a
register. */
static int
-maybe_memory_address_p (mode, ad, part)
- enum machine_mode mode;
- rtx ad;
- rtx *part;
+maybe_memory_address_p (enum machine_mode mode, rtx ad, rtx *part)
{
int retv;
rtx tem = *part;
to a hard register, and frame pointer elimination. */
static int
-find_reloads_address (mode, memrefloc, ad, loc, opnum, type, ind_levels, insn)
- enum machine_mode mode;
- rtx *memrefloc;
- rtx ad;
- rtx *loc;
- int opnum;
- enum reload_type type;
- int ind_levels;
- rtx insn;
+find_reloads_address (enum machine_mode mode, rtx *memrefloc, rtx ad,
+ rtx *loc, int opnum, enum reload_type type,
+ int ind_levels, rtx insn)
{
int regno;
int removed_and = 0;
front of it for pseudos that we have to replace with stack slots. */
static rtx
-subst_reg_equivs (ad, insn)
- rtx ad;
- rtx insn;
+subst_reg_equivs (rtx ad, rtx insn)
{
RTX_CODE code = GET_CODE (ad);
int i;
This routine assumes both inputs are already in canonical form. */
rtx
-form_sum (x, y)
- rtx x, y;
+form_sum (rtx x, rtx y)
{
rtx tem;
enum machine_mode mode = GET_MODE (x);
In all other cases, return ADDR. */
static rtx
-subst_indexed_address (addr)
- rtx addr;
+subst_indexed_address (rtx addr)
{
rtx op0 = 0, op1 = 0, op2 = 0;
rtx tem;
RELOADNUM is the reload number. */
static void
-update_auto_inc_notes (insn, regno, reloadnum)
- rtx insn ATTRIBUTE_UNUSED;
- int regno ATTRIBUTE_UNUSED;
- int reloadnum ATTRIBUTE_UNUSED;
+update_auto_inc_notes (rtx insn ATTRIBUTE_UNUSED, int regno ATTRIBUTE_UNUSED,
+ int reloadnum ATTRIBUTE_UNUSED)
{
#ifdef AUTO_INC_DEC
rtx link;
could have addressing modes that this does not handle right. */
static int
-find_reloads_address_1 (mode, x, context, loc, opnum, type, ind_levels, insn)
- enum machine_mode mode;
- rtx x;
- int context;
- rtx *loc;
- int opnum;
- enum reload_type type;
- int ind_levels;
- rtx insn;
+find_reloads_address_1 (enum machine_mode mode, rtx x, int context,
+ rtx *loc, int opnum, enum reload_type type,
+ int ind_levels, rtx insn)
{
RTX_CODE code = GET_CODE (x);
GET_MODE (orig_op1))));
}
/* Plus in the index register may be created only as a result of
- register remateralization for expresion like &localvar*4. Reload it.
+ register remateralization for expression like &localvar*4. Reload it.
It may be possible to combine the displacement on the outer level,
but it is probably not worthwhile to do so. */
if (context)
/* Handle a register that is equivalent to a memory location
which cannot be addressed directly. */
- if (reg_equiv_memory_loc[regno] != 0
+ if (reg_equiv_memory_loc[regno] != 0
&& (reg_equiv_address[regno] != 0
|| num_not_at_initial_offset))
{
supports. */
static void
-find_reloads_address_part (x, loc, class, mode, opnum, type, ind_levels)
- rtx x;
- rtx *loc;
- enum reg_class class;
- enum machine_mode mode;
- int opnum;
- enum reload_type type;
- int ind_levels;
+find_reloads_address_part (rtx x, rtx *loc, enum reg_class class,
+ enum machine_mode mode, int opnum,
+ enum reload_type type, int ind_levels)
{
if (CONSTANT_P (x)
&& (! LEGITIMATE_CONSTANT_P (x)
stack slots. */
static rtx
-find_reloads_subreg_address (x, force_replace, opnum, type,
- ind_levels, insn)
- rtx x;
- int force_replace;
- int opnum;
- enum reload_type type;
- int ind_levels;
- rtx insn;
+find_reloads_subreg_address (rtx x, int force_replace, int opnum,
+ enum reload_type type, int ind_levels, rtx insn)
{
int regno = REGNO (SUBREG_REG (x));
Return the rtx that X translates into; usually X, but modified. */
void
-subst_reloads (insn)
- rtx insn;
+subst_reloads (rtx insn)
{
int i;
copies to locations in Y, a copy of X. */
void
-copy_replacements (x, y)
- rtx x, y;
+copy_replacements (rtx x, rtx y)
{
/* We can't support X being a SUBREG because we might then need to know its
location if something inside it was replaced. */
}
static void
-copy_replacements_1 (px, py, orig_replacements)
- rtx *px;
- rtx *py;
- int orig_replacements;
+copy_replacements_1 (rtx *px, rtx *py, int orig_replacements)
{
int i, j;
rtx x, y;
/* Change any replacements being done to *X to be done to *Y. */
void
-move_replacements (x, y)
- rtx *x;
- rtx *y;
+move_replacements (rtx *x, rtx *y)
{
int i;
Otherwise, return *LOC. */
rtx
-find_replacement (loc)
- rtx *loc;
+find_replacement (rtx *loc)
{
struct replacement *r;
look at equivalences for pseudos that didn't get hard registers. */
int
-refers_to_regno_for_reload_p (regno, endregno, x, loc)
- unsigned int regno, endregno;
- rtx x;
- rtx *loc;
+refers_to_regno_for_reload_p (unsigned int regno, unsigned int endregno,
+ rtx x, rtx *loc)
{
int i;
unsigned int r;
that we look at equivalences for pseudos that didn't get hard registers. */
int
-reg_overlap_mentioned_for_reload_p (x, in)
- rtx x, in;
+reg_overlap_mentioned_for_reload_p (rtx x, rtx in)
{
int regno, endregno;
registers. */
int
-refers_to_mem_for_reload_p (x)
- rtx x;
+refers_to_mem_for_reload_p (rtx x)
{
const char *fmt;
int i;
as if it were a constant except that sp is required to be unchanging. */
rtx
-find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
- rtx goal;
- rtx insn;
- enum reg_class class;
- int other;
- short *reload_reg_p;
- int goalreg;
- enum machine_mode mode;
+find_equiv_reg (rtx goal, rtx insn, enum reg_class class, int other,
+ short *reload_reg_p, int goalreg, enum machine_mode mode)
{
rtx p = insn;
rtx goaltry, valtry, value, where;
The value is always positive. */
static int
-find_inc_amount (x, inced)
- rtx x, inced;
+find_inc_amount (rtx x, rtx inced)
{
enum rtx_code code = GET_CODE (x);
const char *fmt;
If SETS is nonzero, also consider SETs. */
int
-regno_clobbered_p (regno, insn, mode, sets)
- unsigned int regno;
- rtx insn;
- enum machine_mode mode;
- int sets;
+regno_clobbered_p (unsigned int regno, rtx insn, enum machine_mode mode,
+ int sets)
{
unsigned int nregs = HARD_REGNO_NREGS (regno, mode);
unsigned int endregno = regno + nregs;
/* Find the low part, with mode MODE, of a hard regno RELOADREG. */
rtx
-reload_adjust_reg_for_mode (reloadreg, mode)
- rtx reloadreg;
- enum machine_mode mode;
+reload_adjust_reg_for_mode (rtx reloadreg, enum machine_mode mode)
{
int regno;
/* These functions are used to print the variables set by 'find_reloads' */
void
-debug_reload_to_stream (f)
- FILE *f;
+debug_reload_to_stream (FILE *f)
{
int r;
const char *prefix;
}
void
-debug_reload ()
+debug_reload (void)
{
debug_reload_to_stream (stderr);
}
OSDN Git Service
