/* Search an insn for pseudo regs that must be in hard regs and are not.
|
/* Search an insn for pseudo regs that must be in hard regs and are not.
|
Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
|
Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
|
1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 , 2007
|
1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 , 2007
|
Free Software Foundation, Inc.
|
Free Software Foundation, Inc.
|
|
|
This file is part of GCC.
|
This file is part of GCC.
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
GCC is free software; you can redistribute it and/or modify it under
|
the terms of the GNU General Public License as published by the Free
|
the terms of the GNU General Public License as published by the Free
|
Software Foundation; either version 3, or (at your option) any later
|
Software Foundation; either version 3, or (at your option) any later
|
version.
|
version.
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
for more details.
|
for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with GCC; see the file COPYING3. If not see
|
along with GCC; see the file COPYING3. If not see
|
<http://www.gnu.org/licenses/>. */
|
<http://www.gnu.org/licenses/>. */
|
|
|
/* This file contains subroutines used only from the file reload1.c.
|
/* This file contains subroutines used only from the file reload1.c.
|
It knows how to scan one insn for operands and values
|
It knows how to scan one insn for operands and values
|
that need to be copied into registers to make valid code.
|
that need to be copied into registers to make valid code.
|
It also finds other operands and values which are valid
|
It also finds other operands and values which are valid
|
but for which equivalent values in registers exist and
|
but for which equivalent values in registers exist and
|
ought to be used instead.
|
ought to be used instead.
|
|
|
Before processing the first insn of the function, call `init_reload'.
|
Before processing the first insn of the function, call `init_reload'.
|
init_reload actually has to be called earlier anyway.
|
init_reload actually has to be called earlier anyway.
|
|
|
To scan an insn, call `find_reloads'. This does two things:
|
To scan an insn, call `find_reloads'. This does two things:
|
1. sets up tables describing which values must be reloaded
|
1. sets up tables describing which values must be reloaded
|
for this insn, and what kind of hard regs they must be reloaded into;
|
for this insn, and what kind of hard regs they must be reloaded into;
|
2. optionally record the locations where those values appear in
|
2. optionally record the locations where those values appear in
|
the data, so they can be replaced properly later.
|
the data, so they can be replaced properly later.
|
This is done only if the second arg to `find_reloads' is nonzero.
|
This is done only if the second arg to `find_reloads' is nonzero.
|
|
|
The third arg to `find_reloads' specifies the number of levels
|
The third arg to `find_reloads' specifies the number of levels
|
of indirect addressing supported by the machine. If it is zero,
|
of indirect addressing supported by the machine. If it is zero,
|
indirect addressing is not valid. If it is one, (MEM (REG n))
|
indirect addressing is not valid. If it is one, (MEM (REG n))
|
is valid even if (REG n) did not get a hard register; if it is two,
|
is valid even if (REG n) did not get a hard register; if it is two,
|
(MEM (MEM (REG n))) is also valid even if (REG n) did not get a
|
(MEM (MEM (REG n))) is also valid even if (REG n) did not get a
|
hard register, and similarly for higher values.
|
hard register, and similarly for higher values.
|
|
|
Then you must choose the hard regs to reload those pseudo regs into,
|
Then you must choose the hard regs to reload those pseudo regs into,
|
and generate appropriate load insns before this insn and perhaps
|
and generate appropriate load insns before this insn and perhaps
|
also store insns after this insn. Set up the array `reload_reg_rtx'
|
also store insns after this insn. Set up the array `reload_reg_rtx'
|
to contain the REG rtx's for the registers you used. In some
|
to contain the REG rtx's for the registers you used. In some
|
cases `find_reloads' will return a nonzero value in `reload_reg_rtx'
|
cases `find_reloads' will return a nonzero value in `reload_reg_rtx'
|
for certain reloads. Then that tells you which register to use,
|
for certain reloads. Then that tells you which register to use,
|
so you do not need to allocate one. But you still do need to add extra
|
so you do not need to allocate one. But you still do need to add extra
|
instructions to copy the value into and out of that register.
|
instructions to copy the value into and out of that register.
|
|
|
Finally you must call `subst_reloads' to substitute the reload reg rtx's
|
Finally you must call `subst_reloads' to substitute the reload reg rtx's
|
into the locations already recorded.
|
into the locations already recorded.
|
|
|
NOTE SIDE EFFECTS:
|
NOTE SIDE EFFECTS:
|
|
|
find_reloads can alter the operands of the instruction it is called on.
|
find_reloads can alter the operands of the instruction it is called on.
|
|
|
1. Two operands of any sort may be interchanged, if they are in a
|
1. Two operands of any sort may be interchanged, if they are in a
|
commutative instruction.
|
commutative instruction.
|
This happens only if find_reloads thinks the instruction will compile
|
This happens only if find_reloads thinks the instruction will compile
|
better that way.
|
better that way.
|
|
|
2. Pseudo-registers that are equivalent to constants are replaced
|
2. Pseudo-registers that are equivalent to constants are replaced
|
with those constants if they are not in hard registers.
|
with those constants if they are not in hard registers.
|
|
|
1 happens every time find_reloads is called.
|
1 happens every time find_reloads is called.
|
2 happens only when REPLACE is 1, which is only when
|
2 happens only when REPLACE is 1, which is only when
|
actually doing the reloads, not when just counting them.
|
actually doing the reloads, not when just counting them.
|
|
|
Using a reload register for several reloads in one insn:
|
Using a reload register for several reloads in one insn:
|
|
|
When an insn has reloads, it is considered as having three parts:
|
When an insn has reloads, it is considered as having three parts:
|
the input reloads, the insn itself after reloading, and the output reloads.
|
the input reloads, the insn itself after reloading, and the output reloads.
|
Reloads of values used in memory addresses are often needed for only one part.
|
Reloads of values used in memory addresses are often needed for only one part.
|
|
|
When this is so, reload_when_needed records which part needs the reload.
|
When this is so, reload_when_needed records which part needs the reload.
|
Two reloads for different parts of the insn can share the same reload
|
Two reloads for different parts of the insn can share the same reload
|
register.
|
register.
|
|
|
When a reload is used for addresses in multiple parts, or when it is
|
When a reload is used for addresses in multiple parts, or when it is
|
an ordinary operand, it is classified as RELOAD_OTHER, and cannot share
|
an ordinary operand, it is classified as RELOAD_OTHER, and cannot share
|
a register with any other reload. */
|
a register with any other reload. */
|
|
|
#define REG_OK_STRICT
|
#define REG_OK_STRICT
|
|
|
#include "config.h"
|
#include "config.h"
|
#include "system.h"
|
#include "system.h"
|
#include "coretypes.h"
|
#include "coretypes.h"
|
#include "tm.h"
|
#include "tm.h"
|
#include "rtl.h"
|
#include "rtl.h"
|
#include "tm_p.h"
|
#include "tm_p.h"
|
#include "insn-config.h"
|
#include "insn-config.h"
|
#include "expr.h"
|
#include "expr.h"
|
#include "optabs.h"
|
#include "optabs.h"
|
#include "recog.h"
|
#include "recog.h"
|
#include "reload.h"
|
#include "reload.h"
|
#include "regs.h"
|
#include "regs.h"
|
#include "addresses.h"
|
#include "addresses.h"
|
#include "hard-reg-set.h"
|
#include "hard-reg-set.h"
|
#include "flags.h"
|
#include "flags.h"
|
#include "real.h"
|
#include "real.h"
|
#include "output.h"
|
#include "output.h"
|
#include "function.h"
|
#include "function.h"
|
#include "toplev.h"
|
#include "toplev.h"
|
#include "params.h"
|
#include "params.h"
|
#include "target.h"
|
#include "target.h"
|
|
|
/* True if X is a constant that can be forced into the constant pool. */
|
/* True if X is a constant that can be forced into the constant pool. */
|
#define CONST_POOL_OK_P(X) \
|
#define CONST_POOL_OK_P(X) \
|
(CONSTANT_P (X) \
|
(CONSTANT_P (X) \
|
&& GET_CODE (X) != HIGH \
|
&& GET_CODE (X) != HIGH \
|
&& !targetm.cannot_force_const_mem (X))
|
&& !targetm.cannot_force_const_mem (X))
|
|
|
/* True if C is a non-empty register class that has too few registers
|
/* True if C is a non-empty register class that has too few registers
|
to be safely used as a reload target class. */
|
to be safely used as a reload target class. */
|
#define SMALL_REGISTER_CLASS_P(C) \
|
#define SMALL_REGISTER_CLASS_P(C) \
|
(reg_class_size [(C)] == 1 \
|
(reg_class_size [(C)] == 1 \
|
|| (reg_class_size [(C)] >= 1 && CLASS_LIKELY_SPILLED_P (C)))
|
|| (reg_class_size [(C)] >= 1 && CLASS_LIKELY_SPILLED_P (C)))
|
|
|
|
|
/* All reloads of the current insn are recorded here. See reload.h for
|
/* All reloads of the current insn are recorded here. See reload.h for
|
comments. */
|
comments. */
|
int n_reloads;
|
int n_reloads;
|
struct reload rld[MAX_RELOADS];
|
struct reload rld[MAX_RELOADS];
|
|
|
/* All the "earlyclobber" operands of the current insn
|
/* All the "earlyclobber" operands of the current insn
|
are recorded here. */
|
are recorded here. */
|
int n_earlyclobbers;
|
int n_earlyclobbers;
|
rtx reload_earlyclobbers[MAX_RECOG_OPERANDS];
|
rtx reload_earlyclobbers[MAX_RECOG_OPERANDS];
|
|
|
int reload_n_operands;
|
int reload_n_operands;
|
|
|
/* Replacing reloads.
|
/* Replacing reloads.
|
|
|
If `replace_reloads' is nonzero, then as each reload is recorded
|
If `replace_reloads' is nonzero, then as each reload is recorded
|
an entry is made for it in the table `replacements'.
|
an entry is made for it in the table `replacements'.
|
Then later `subst_reloads' can look through that table and
|
Then later `subst_reloads' can look through that table and
|
perform all the replacements needed. */
|
perform all the replacements needed. */
|
|
|
/* Nonzero means record the places to replace. */
|
/* Nonzero means record the places to replace. */
|
static int replace_reloads;
|
static int replace_reloads;
|
|
|
/* Each replacement is recorded with a structure like this. */
|
/* Each replacement is recorded with a structure like this. */
|
struct replacement
|
struct replacement
|
{
|
{
|
rtx *where; /* Location to store in */
|
rtx *where; /* Location to store in */
|
rtx *subreg_loc; /* Location of SUBREG if WHERE is inside
|
rtx *subreg_loc; /* Location of SUBREG if WHERE is inside
|
a SUBREG; 0 otherwise. */
|
a SUBREG; 0 otherwise. */
|
int what; /* which reload this is for */
|
int what; /* which reload this is for */
|
enum machine_mode mode; /* mode it must have */
|
enum machine_mode mode; /* mode it must have */
|
};
|
};
|
|
|
static struct replacement replacements[MAX_RECOG_OPERANDS * ((MAX_REGS_PER_ADDRESS * 2) + 1)];
|
static struct replacement replacements[MAX_RECOG_OPERANDS * ((MAX_REGS_PER_ADDRESS * 2) + 1)];
|
|
|
/* Number of replacements currently recorded. */
|
/* Number of replacements currently recorded. */
|
static int n_replacements;
|
static int n_replacements;
|
|
|
/* Used to track what is modified by an operand. */
|
/* Used to track what is modified by an operand. */
|
struct decomposition
|
struct decomposition
|
{
|
{
|
int reg_flag; /* Nonzero if referencing a register. */
|
int reg_flag; /* Nonzero if referencing a register. */
|
int safe; /* Nonzero if this can't conflict with anything. */
|
int safe; /* Nonzero if this can't conflict with anything. */
|
rtx base; /* Base address for MEM. */
|
rtx base; /* Base address for MEM. */
|
HOST_WIDE_INT start; /* Starting offset or register number. */
|
HOST_WIDE_INT start; /* Starting offset or register number. */
|
HOST_WIDE_INT end; /* Ending offset or register number. */
|
HOST_WIDE_INT end; /* Ending offset or register number. */
|
};
|
};
|
|
|
#ifdef SECONDARY_MEMORY_NEEDED
|
#ifdef SECONDARY_MEMORY_NEEDED
|
|
|
/* Save MEMs needed to copy from one class of registers to another. One MEM
|
/* Save MEMs needed to copy from one class of registers to another. One MEM
|
is used per mode, but normally only one or two modes are ever used.
|
is used per mode, but normally only one or two modes are ever used.
|
|
|
We keep two versions, before and after register elimination. The one
|
We keep two versions, before and after register elimination. The one
|
after register elimination is record separately for each operand. This
|
after register elimination is record separately for each operand. This
|
is done in case the address is not valid to be sure that we separately
|
is done in case the address is not valid to be sure that we separately
|
reload each. */
|
reload each. */
|
|
|
static rtx secondary_memlocs[NUM_MACHINE_MODES];
|
static rtx secondary_memlocs[NUM_MACHINE_MODES];
|
static rtx secondary_memlocs_elim[NUM_MACHINE_MODES][MAX_RECOG_OPERANDS];
|
static rtx secondary_memlocs_elim[NUM_MACHINE_MODES][MAX_RECOG_OPERANDS];
|
static int secondary_memlocs_elim_used = 0;
|
static int secondary_memlocs_elim_used = 0;
|
#endif
|
#endif
|
|
|
/* The instruction we are doing reloads for;
|
/* The instruction we are doing reloads for;
|
so we can test whether a register dies in it. */
|
so we can test whether a register dies in it. */
|
static rtx this_insn;
|
static rtx this_insn;
|
|
|
/* Nonzero if this instruction is a user-specified asm with operands. */
|
/* Nonzero if this instruction is a user-specified asm with operands. */
|
static int this_insn_is_asm;
|
static int this_insn_is_asm;
|
|
|
/* If hard_regs_live_known is nonzero,
|
/* If hard_regs_live_known is nonzero,
|
we can tell which hard regs are currently live,
|
we can tell which hard regs are currently live,
|
at least enough to succeed in choosing dummy reloads. */
|
at least enough to succeed in choosing dummy reloads. */
|
static int hard_regs_live_known;
|
static int hard_regs_live_known;
|
|
|
/* Indexed by hard reg number,
|
/* Indexed by hard reg number,
|
element is nonnegative if hard reg has been spilled.
|
element is nonnegative if hard reg has been spilled.
|
This vector is passed to `find_reloads' as an argument
|
This vector is passed to `find_reloads' as an argument
|
and is not changed here. */
|
and is not changed here. */
|
static short *static_reload_reg_p;
|
static short *static_reload_reg_p;
|
|
|
/* Set to 1 in subst_reg_equivs if it changes anything. */
|
/* Set to 1 in subst_reg_equivs if it changes anything. */
|
static int subst_reg_equivs_changed;
|
static int subst_reg_equivs_changed;
|
|
|
/* On return from push_reload, holds the reload-number for the OUT
|
/* On return from push_reload, holds the reload-number for the OUT
|
operand, which can be different for that from the input operand. */
|
operand, which can be different for that from the input operand. */
|
static int output_reloadnum;
|
static int output_reloadnum;
|
|
|
/* Compare two RTX's. */
|
/* Compare two RTX's. */
|
#define MATCHES(x, y) \
|
#define MATCHES(x, y) \
|
(x == y || (x != 0 && (REG_P (x) \
|
(x == y || (x != 0 && (REG_P (x) \
|
? REG_P (y) && REGNO (x) == REGNO (y) \
|
? REG_P (y) && REGNO (x) == REGNO (y) \
|
: rtx_equal_p (x, y) && ! side_effects_p (x))))
|
: rtx_equal_p (x, y) && ! side_effects_p (x))))
|
|
|
/* Indicates if two reloads purposes are for similar enough things that we
|
/* Indicates if two reloads purposes are for similar enough things that we
|
can merge their reloads. */
|
can merge their reloads. */
|
#define MERGABLE_RELOADS(when1, when2, op1, op2) \
|
#define MERGABLE_RELOADS(when1, when2, op1, op2) \
|
((when1) == RELOAD_OTHER || (when2) == RELOAD_OTHER \
|
((when1) == RELOAD_OTHER || (when2) == RELOAD_OTHER \
|
|| ((when1) == (when2) && (op1) == (op2)) \
|
|| ((when1) == (when2) && (op1) == (op2)) \
|
|| ((when1) == RELOAD_FOR_INPUT && (when2) == RELOAD_FOR_INPUT) \
|
|| ((when1) == RELOAD_FOR_INPUT && (when2) == RELOAD_FOR_INPUT) \
|
|| ((when1) == RELOAD_FOR_OPERAND_ADDRESS \
|
|| ((when1) == RELOAD_FOR_OPERAND_ADDRESS \
|
&& (when2) == RELOAD_FOR_OPERAND_ADDRESS) \
|
&& (when2) == RELOAD_FOR_OPERAND_ADDRESS) \
|
|| ((when1) == RELOAD_FOR_OTHER_ADDRESS \
|
|| ((when1) == RELOAD_FOR_OTHER_ADDRESS \
|
&& (when2) == RELOAD_FOR_OTHER_ADDRESS))
|
&& (when2) == RELOAD_FOR_OTHER_ADDRESS))
|
|
|
/* Nonzero if these two reload purposes produce RELOAD_OTHER when merged. */
|
/* Nonzero if these two reload purposes produce RELOAD_OTHER when merged. */
|
#define MERGE_TO_OTHER(when1, when2, op1, op2) \
|
#define MERGE_TO_OTHER(when1, when2, op1, op2) \
|
((when1) != (when2) \
|
((when1) != (when2) \
|
|| ! ((op1) == (op2) \
|
|| ! ((op1) == (op2) \
|
|| (when1) == RELOAD_FOR_INPUT \
|
|| (when1) == RELOAD_FOR_INPUT \
|
|| (when1) == RELOAD_FOR_OPERAND_ADDRESS \
|
|| (when1) == RELOAD_FOR_OPERAND_ADDRESS \
|
|| (when1) == RELOAD_FOR_OTHER_ADDRESS))
|
|| (when1) == RELOAD_FOR_OTHER_ADDRESS))
|
|
|
/* If we are going to reload an address, compute the reload type to
|
/* If we are going to reload an address, compute the reload type to
|
use. */
|
use. */
|
#define ADDR_TYPE(type) \
|
#define ADDR_TYPE(type) \
|
((type) == RELOAD_FOR_INPUT_ADDRESS \
|
((type) == RELOAD_FOR_INPUT_ADDRESS \
|
? RELOAD_FOR_INPADDR_ADDRESS \
|
? RELOAD_FOR_INPADDR_ADDRESS \
|
: ((type) == RELOAD_FOR_OUTPUT_ADDRESS \
|
: ((type) == RELOAD_FOR_OUTPUT_ADDRESS \
|
? RELOAD_FOR_OUTADDR_ADDRESS \
|
? RELOAD_FOR_OUTADDR_ADDRESS \
|
: (type)))
|
: (type)))
|
|
|
static int push_secondary_reload (int, rtx, int, int, enum reg_class,
|
static int push_secondary_reload (int, rtx, int, int, enum reg_class,
|
enum machine_mode, enum reload_type,
|
enum machine_mode, enum reload_type,
|
enum insn_code *, secondary_reload_info *);
|
enum insn_code *, secondary_reload_info *);
|
static enum reg_class find_valid_class (enum machine_mode, enum machine_mode,
|
static enum reg_class find_valid_class (enum machine_mode, enum machine_mode,
|
int, unsigned int);
|
int, unsigned int);
|
static int reload_inner_reg_of_subreg (rtx, enum machine_mode, int);
|
static int reload_inner_reg_of_subreg (rtx, enum machine_mode, int);
|
static void push_replacement (rtx *, int, enum machine_mode);
|
static void push_replacement (rtx *, int, enum machine_mode);
|
static void dup_replacements (rtx *, rtx *);
|
static void dup_replacements (rtx *, rtx *);
|
static void combine_reloads (void);
|
static void combine_reloads (void);
|
static int find_reusable_reload (rtx *, rtx, enum reg_class,
|
static int find_reusable_reload (rtx *, rtx, enum reg_class,
|
enum reload_type, int, int);
|
enum reload_type, int, int);
|
static rtx find_dummy_reload (rtx, rtx, rtx *, rtx *, enum machine_mode,
|
static rtx find_dummy_reload (rtx, rtx, rtx *, rtx *, enum machine_mode,
|
enum machine_mode, enum reg_class, int, int);
|
enum machine_mode, enum reg_class, int, int);
|
static int hard_reg_set_here_p (unsigned int, unsigned int, rtx);
|
static int hard_reg_set_here_p (unsigned int, unsigned int, rtx);
|
static struct decomposition decompose (rtx);
|
static struct decomposition decompose (rtx);
|
static int immune_p (rtx, rtx, struct decomposition);
|
static int immune_p (rtx, rtx, struct decomposition);
|
static int alternative_allows_memconst (const char *, int);
|
static int alternative_allows_memconst (const char *, int);
|
static rtx find_reloads_toplev (rtx, int, enum reload_type, int, int, rtx,
|
static rtx find_reloads_toplev (rtx, int, enum reload_type, int, int, rtx,
|
int *);
|
int *);
|
static rtx make_memloc (rtx, int);
|
static rtx make_memloc (rtx, int);
|
static int maybe_memory_address_p (enum machine_mode, rtx, rtx *);
|
static int maybe_memory_address_p (enum machine_mode, rtx, rtx *);
|
static int find_reloads_address (enum machine_mode, rtx *, rtx, rtx *,
|
static int find_reloads_address (enum machine_mode, rtx *, rtx, rtx *,
|
int, enum reload_type, int, rtx);
|
int, enum reload_type, int, rtx);
|
static rtx subst_reg_equivs (rtx, rtx);
|
static rtx subst_reg_equivs (rtx, rtx);
|
static rtx subst_indexed_address (rtx);
|
static rtx subst_indexed_address (rtx);
|
static void update_auto_inc_notes (rtx, int, int);
|
static void update_auto_inc_notes (rtx, int, int);
|
static int find_reloads_address_1 (enum machine_mode, rtx, int,
|
static int find_reloads_address_1 (enum machine_mode, rtx, int,
|
enum rtx_code, enum rtx_code, rtx *,
|
enum rtx_code, enum rtx_code, rtx *,
|
int, enum reload_type,int, rtx);
|
int, enum reload_type,int, rtx);
|
static void find_reloads_address_part (rtx, rtx *, enum reg_class,
|
static void find_reloads_address_part (rtx, rtx *, enum reg_class,
|
enum machine_mode, int,
|
enum machine_mode, int,
|
enum reload_type, int);
|
enum reload_type, int);
|
static rtx find_reloads_subreg_address (rtx, int, int, enum reload_type,
|
static rtx find_reloads_subreg_address (rtx, int, int, enum reload_type,
|
int, rtx);
|
int, rtx);
|
static void copy_replacements_1 (rtx *, rtx *, int);
|
static void copy_replacements_1 (rtx *, rtx *, int);
|
static int find_inc_amount (rtx, rtx);
|
static int find_inc_amount (rtx, rtx);
|
static int refers_to_mem_for_reload_p (rtx);
|
static int refers_to_mem_for_reload_p (rtx);
|
static int refers_to_regno_for_reload_p (unsigned int, unsigned int,
|
static int refers_to_regno_for_reload_p (unsigned int, unsigned int,
|
rtx, rtx *);
|
rtx, rtx *);
|
|
|
/* Add NEW to reg_equiv_alt_mem_list[REGNO] if it's not present in the
|
/* Add NEW to reg_equiv_alt_mem_list[REGNO] if it's not present in the
|
list yet. */
|
list yet. */
|
|
|
static void
|
static void
|
push_reg_equiv_alt_mem (int regno, rtx mem)
|
push_reg_equiv_alt_mem (int regno, rtx mem)
|
{
|
{
|
rtx it;
|
rtx it;
|
|
|
for (it = reg_equiv_alt_mem_list [regno]; it; it = XEXP (it, 1))
|
for (it = reg_equiv_alt_mem_list [regno]; it; it = XEXP (it, 1))
|
if (rtx_equal_p (XEXP (it, 0), mem))
|
if (rtx_equal_p (XEXP (it, 0), mem))
|
return;
|
return;
|
|
|
reg_equiv_alt_mem_list [regno]
|
reg_equiv_alt_mem_list [regno]
|
= alloc_EXPR_LIST (REG_EQUIV, mem,
|
= alloc_EXPR_LIST (REG_EQUIV, mem,
|
reg_equiv_alt_mem_list [regno]);
|
reg_equiv_alt_mem_list [regno]);
|
}
|
}
|
|
|
/* Determine if any secondary reloads are needed for loading (if IN_P is
|
/* Determine if any secondary reloads are needed for loading (if IN_P is
|
nonzero) or storing (if IN_P is zero) X to or from a reload register of
|
nonzero) or storing (if IN_P is zero) X to or from a reload register of
|
register class RELOAD_CLASS in mode RELOAD_MODE. If secondary reloads
|
register class RELOAD_CLASS in mode RELOAD_MODE. If secondary reloads
|
are needed, push them.
|
are needed, push them.
|
|
|
Return the reload number of the secondary reload we made, or -1 if
|
Return the reload number of the secondary reload we made, or -1 if
|
we didn't need one. *PICODE is set to the insn_code to use if we do
|
we didn't need one. *PICODE is set to the insn_code to use if we do
|
need a secondary reload. */
|
need a secondary reload. */
|
|
|
static int
|
static int
|
push_secondary_reload (int in_p, rtx x, int opnum, int optional,
|
push_secondary_reload (int in_p, rtx x, int opnum, int optional,
|
enum reg_class reload_class,
|
enum reg_class reload_class,
|
enum machine_mode reload_mode, enum reload_type type,
|
enum machine_mode reload_mode, enum reload_type type,
|
enum insn_code *picode, secondary_reload_info *prev_sri)
|
enum insn_code *picode, secondary_reload_info *prev_sri)
|
{
|
{
|
enum reg_class class = NO_REGS;
|
enum reg_class class = NO_REGS;
|
enum reg_class scratch_class;
|
enum reg_class scratch_class;
|
enum machine_mode mode = reload_mode;
|
enum machine_mode mode = reload_mode;
|
enum insn_code icode = CODE_FOR_nothing;
|
enum insn_code icode = CODE_FOR_nothing;
|
enum insn_code t_icode = CODE_FOR_nothing;
|
enum insn_code t_icode = CODE_FOR_nothing;
|
enum reload_type secondary_type;
|
enum reload_type secondary_type;
|
int s_reload, t_reload = -1;
|
int s_reload, t_reload = -1;
|
const char *scratch_constraint;
|
const char *scratch_constraint;
|
char letter;
|
char letter;
|
secondary_reload_info sri;
|
secondary_reload_info sri;
|
|
|
if (type == RELOAD_FOR_INPUT_ADDRESS
|
if (type == RELOAD_FOR_INPUT_ADDRESS
|
|| type == RELOAD_FOR_OUTPUT_ADDRESS
|
|| type == RELOAD_FOR_OUTPUT_ADDRESS
|
|| type == RELOAD_FOR_INPADDR_ADDRESS
|
|| type == RELOAD_FOR_INPADDR_ADDRESS
|
|| type == RELOAD_FOR_OUTADDR_ADDRESS)
|
|| type == RELOAD_FOR_OUTADDR_ADDRESS)
|
secondary_type = type;
|
secondary_type = type;
|
else
|
else
|
secondary_type = in_p ? RELOAD_FOR_INPUT_ADDRESS : RELOAD_FOR_OUTPUT_ADDRESS;
|
secondary_type = in_p ? RELOAD_FOR_INPUT_ADDRESS : RELOAD_FOR_OUTPUT_ADDRESS;
|
|
|
*picode = CODE_FOR_nothing;
|
*picode = CODE_FOR_nothing;
|
|
|
/* If X is a paradoxical SUBREG, use the inner value to determine both the
|
/* If X is a paradoxical SUBREG, use the inner value to determine both the
|
mode and object being reloaded. */
|
mode and object being reloaded. */
|
if (GET_CODE (x) == SUBREG
|
if (GET_CODE (x) == SUBREG
|
&& (GET_MODE_SIZE (GET_MODE (x))
|
&& (GET_MODE_SIZE (GET_MODE (x))
|
> GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)))))
|
> GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)))))
|
{
|
{
|
x = SUBREG_REG (x);
|
x = SUBREG_REG (x);
|
reload_mode = GET_MODE (x);
|
reload_mode = GET_MODE (x);
|
}
|
}
|
|
|
/* If X is a pseudo-register that has an equivalent MEM (actually, if it
|
/* If X is a pseudo-register that has an equivalent MEM (actually, if it
|
is still a pseudo-register by now, it *must* have an equivalent MEM
|
is still a pseudo-register by now, it *must* have an equivalent MEM
|
but we don't want to assume that), use that equivalent when seeing if
|
but we don't want to assume that), use that equivalent when seeing if
|
a secondary reload is needed since whether or not a reload is needed
|
a secondary reload is needed since whether or not a reload is needed
|
might be sensitive to the form of the MEM. */
|
might be sensitive to the form of the MEM. */
|
|
|
if (REG_P (x) && REGNO (x) >= FIRST_PSEUDO_REGISTER
|
if (REG_P (x) && REGNO (x) >= FIRST_PSEUDO_REGISTER
|
&& reg_equiv_mem[REGNO (x)] != 0)
|
&& reg_equiv_mem[REGNO (x)] != 0)
|
x = reg_equiv_mem[REGNO (x)];
|
x = reg_equiv_mem[REGNO (x)];
|
|
|
sri.icode = CODE_FOR_nothing;
|
sri.icode = CODE_FOR_nothing;
|
sri.prev_sri = prev_sri;
|
sri.prev_sri = prev_sri;
|
class = targetm.secondary_reload (in_p, x, reload_class, reload_mode, &sri);
|
class = targetm.secondary_reload (in_p, x, reload_class, reload_mode, &sri);
|
icode = sri.icode;
|
icode = sri.icode;
|
|
|
/* If we don't need any secondary registers, done. */
|
/* If we don't need any secondary registers, done. */
|
if (class == NO_REGS && icode == CODE_FOR_nothing)
|
if (class == NO_REGS && icode == CODE_FOR_nothing)
|
return -1;
|
return -1;
|
|
|
if (class != NO_REGS)
|
if (class != NO_REGS)
|
t_reload = push_secondary_reload (in_p, x, opnum, optional, class,
|
t_reload = push_secondary_reload (in_p, x, opnum, optional, class,
|
reload_mode, type, &t_icode, &sri);
|
reload_mode, type, &t_icode, &sri);
|
|
|
/* If we will be using an insn, the secondary reload is for a
|
/* If we will be using an insn, the secondary reload is for a
|
scratch register. */
|
scratch register. */
|
|
|
if (icode != CODE_FOR_nothing)
|
if (icode != CODE_FOR_nothing)
|
{
|
{
|
/* If IN_P is nonzero, the reload register will be the output in
|
/* If IN_P is nonzero, the reload register will be the output in
|
operand 0. If IN_P is zero, the reload register will be the input
|
operand 0. If IN_P is zero, the reload register will be the input
|
in operand 1. Outputs should have an initial "=", which we must
|
in operand 1. Outputs should have an initial "=", which we must
|
skip. */
|
skip. */
|
|
|
/* ??? It would be useful to be able to handle only two, or more than
|
/* ??? It would be useful to be able to handle only two, or more than
|
three, operands, but for now we can only handle the case of having
|
three, operands, but for now we can only handle the case of having
|
exactly three: output, input and one temp/scratch. */
|
exactly three: output, input and one temp/scratch. */
|
gcc_assert (insn_data[(int) icode].n_operands == 3);
|
gcc_assert (insn_data[(int) icode].n_operands == 3);
|
|
|
/* ??? We currently have no way to represent a reload that needs
|
/* ??? We currently have no way to represent a reload that needs
|
an icode to reload from an intermediate tertiary reload register.
|
an icode to reload from an intermediate tertiary reload register.
|
We should probably have a new field in struct reload to tag a
|
We should probably have a new field in struct reload to tag a
|
chain of scratch operand reloads onto. */
|
chain of scratch operand reloads onto. */
|
gcc_assert (class == NO_REGS);
|
gcc_assert (class == NO_REGS);
|
|
|
scratch_constraint = insn_data[(int) icode].operand[2].constraint;
|
scratch_constraint = insn_data[(int) icode].operand[2].constraint;
|
gcc_assert (*scratch_constraint == '=');
|
gcc_assert (*scratch_constraint == '=');
|
scratch_constraint++;
|
scratch_constraint++;
|
if (*scratch_constraint == '&')
|
if (*scratch_constraint == '&')
|
scratch_constraint++;
|
scratch_constraint++;
|
letter = *scratch_constraint;
|
letter = *scratch_constraint;
|
scratch_class = (letter == 'r' ? GENERAL_REGS
|
scratch_class = (letter == 'r' ? GENERAL_REGS
|
: REG_CLASS_FROM_CONSTRAINT ((unsigned char) letter,
|
: REG_CLASS_FROM_CONSTRAINT ((unsigned char) letter,
|
scratch_constraint));
|
scratch_constraint));
|
|
|
class = scratch_class;
|
class = scratch_class;
|
mode = insn_data[(int) icode].operand[2].mode;
|
mode = insn_data[(int) icode].operand[2].mode;
|
}
|
}
|
|
|
/* This case isn't valid, so fail. Reload is allowed to use the same
|
/* This case isn't valid, so fail. Reload is allowed to use the same
|
register for RELOAD_FOR_INPUT_ADDRESS and RELOAD_FOR_INPUT reloads, but
|
register for RELOAD_FOR_INPUT_ADDRESS and RELOAD_FOR_INPUT reloads, but
|
in the case of a secondary register, we actually need two different
|
in the case of a secondary register, we actually need two different
|
registers for correct code. We fail here to prevent the possibility of
|
registers for correct code. We fail here to prevent the possibility of
|
silently generating incorrect code later.
|
silently generating incorrect code later.
|
|
|
The convention is that secondary input reloads are valid only if the
|
The convention is that secondary input reloads are valid only if the
|
secondary_class is different from class. If you have such a case, you
|
secondary_class is different from class. If you have such a case, you
|
can not use secondary reloads, you must work around the problem some
|
can not use secondary reloads, you must work around the problem some
|
other way.
|
other way.
|
|
|
Allow this when a reload_in/out pattern is being used. I.e. assume
|
Allow this when a reload_in/out pattern is being used. I.e. assume
|
that the generated code handles this case. */
|
that the generated code handles this case. */
|
|
|
gcc_assert (!in_p || class != reload_class || icode != CODE_FOR_nothing
|
gcc_assert (!in_p || class != reload_class || icode != CODE_FOR_nothing
|
|| t_icode != CODE_FOR_nothing);
|
|| t_icode != CODE_FOR_nothing);
|
|
|
/* See if we can reuse an existing secondary reload. */
|
/* See if we can reuse an existing secondary reload. */
|
for (s_reload = 0; s_reload < n_reloads; s_reload++)
|
for (s_reload = 0; s_reload < n_reloads; s_reload++)
|
if (rld[s_reload].secondary_p
|
if (rld[s_reload].secondary_p
|
&& (reg_class_subset_p (class, rld[s_reload].class)
|
&& (reg_class_subset_p (class, rld[s_reload].class)
|
|| reg_class_subset_p (rld[s_reload].class, class))
|
|| reg_class_subset_p (rld[s_reload].class, class))
|
&& ((in_p && rld[s_reload].inmode == mode)
|
&& ((in_p && rld[s_reload].inmode == mode)
|
|| (! in_p && rld[s_reload].outmode == mode))
|
|| (! in_p && rld[s_reload].outmode == mode))
|
&& ((in_p && rld[s_reload].secondary_in_reload == t_reload)
|
&& ((in_p && rld[s_reload].secondary_in_reload == t_reload)
|
|| (! in_p && rld[s_reload].secondary_out_reload == t_reload))
|
|| (! in_p && rld[s_reload].secondary_out_reload == t_reload))
|
&& ((in_p && rld[s_reload].secondary_in_icode == t_icode)
|
&& ((in_p && rld[s_reload].secondary_in_icode == t_icode)
|
|| (! in_p && rld[s_reload].secondary_out_icode == t_icode))
|
|| (! in_p && rld[s_reload].secondary_out_icode == t_icode))
|
&& (SMALL_REGISTER_CLASS_P (class) || SMALL_REGISTER_CLASSES)
|
&& (SMALL_REGISTER_CLASS_P (class) || SMALL_REGISTER_CLASSES)
|
&& MERGABLE_RELOADS (secondary_type, rld[s_reload].when_needed,
|
&& MERGABLE_RELOADS (secondary_type, rld[s_reload].when_needed,
|
opnum, rld[s_reload].opnum))
|
opnum, rld[s_reload].opnum))
|
{
|
{
|
if (in_p)
|
if (in_p)
|
rld[s_reload].inmode = mode;
|
rld[s_reload].inmode = mode;
|
if (! in_p)
|
if (! in_p)
|
rld[s_reload].outmode = mode;
|
rld[s_reload].outmode = mode;
|
|
|
if (reg_class_subset_p (class, rld[s_reload].class))
|
if (reg_class_subset_p (class, rld[s_reload].class))
|
rld[s_reload].class = class;
|
rld[s_reload].class = class;
|
|
|
rld[s_reload].opnum = MIN (rld[s_reload].opnum, opnum);
|
rld[s_reload].opnum = MIN (rld[s_reload].opnum, opnum);
|
rld[s_reload].optional &= optional;
|
rld[s_reload].optional &= optional;
|
rld[s_reload].secondary_p = 1;
|
rld[s_reload].secondary_p = 1;
|
if (MERGE_TO_OTHER (secondary_type, rld[s_reload].when_needed,
|
if (MERGE_TO_OTHER (secondary_type, rld[s_reload].when_needed,
|
opnum, rld[s_reload].opnum))
|
opnum, rld[s_reload].opnum))
|
rld[s_reload].when_needed = RELOAD_OTHER;
|
rld[s_reload].when_needed = RELOAD_OTHER;
|
}
|
}
|
|
|
if (s_reload == n_reloads)
|
if (s_reload == n_reloads)
|
{
|
{
|
#ifdef SECONDARY_MEMORY_NEEDED
|
#ifdef SECONDARY_MEMORY_NEEDED
|
/* If we need a memory location to copy between the two reload regs,
|
/* If we need a memory location to copy between the two reload regs,
|
set it up now. Note that we do the input case before making
|
set it up now. Note that we do the input case before making
|
the reload and the output case after. This is due to the
|
the reload and the output case after. This is due to the
|
way reloads are output. */
|
way reloads are output. */
|
|
|
if (in_p && icode == CODE_FOR_nothing
|
if (in_p && icode == CODE_FOR_nothing
|
&& SECONDARY_MEMORY_NEEDED (class, reload_class, mode))
|
&& SECONDARY_MEMORY_NEEDED (class, reload_class, mode))
|
{
|
{
|
get_secondary_mem (x, reload_mode, opnum, type);
|
get_secondary_mem (x, reload_mode, opnum, type);
|
|
|
/* We may have just added new reloads. Make sure we add
|
/* We may have just added new reloads. Make sure we add
|
the new reload at the end. */
|
the new reload at the end. */
|
s_reload = n_reloads;
|
s_reload = n_reloads;
|
}
|
}
|
#endif
|
#endif
|
|
|
/* We need to make a new secondary reload for this register class. */
|
/* We need to make a new secondary reload for this register class. */
|
rld[s_reload].in = rld[s_reload].out = 0;
|
rld[s_reload].in = rld[s_reload].out = 0;
|
rld[s_reload].class = class;
|
rld[s_reload].class = class;
|
|
|
rld[s_reload].inmode = in_p ? mode : VOIDmode;
|
rld[s_reload].inmode = in_p ? mode : VOIDmode;
|
rld[s_reload].outmode = ! in_p ? mode : VOIDmode;
|
rld[s_reload].outmode = ! in_p ? mode : VOIDmode;
|
rld[s_reload].reg_rtx = 0;
|
rld[s_reload].reg_rtx = 0;
|
rld[s_reload].optional = optional;
|
rld[s_reload].optional = optional;
|
rld[s_reload].inc = 0;
|
rld[s_reload].inc = 0;
|
/* Maybe we could combine these, but it seems too tricky. */
|
/* Maybe we could combine these, but it seems too tricky. */
|
rld[s_reload].nocombine = 1;
|
rld[s_reload].nocombine = 1;
|
rld[s_reload].in_reg = 0;
|
rld[s_reload].in_reg = 0;
|
rld[s_reload].out_reg = 0;
|
rld[s_reload].out_reg = 0;
|
rld[s_reload].opnum = opnum;
|
rld[s_reload].opnum = opnum;
|
rld[s_reload].when_needed = secondary_type;
|
rld[s_reload].when_needed = secondary_type;
|
rld[s_reload].secondary_in_reload = in_p ? t_reload : -1;
|
rld[s_reload].secondary_in_reload = in_p ? t_reload : -1;
|
rld[s_reload].secondary_out_reload = ! in_p ? t_reload : -1;
|
rld[s_reload].secondary_out_reload = ! in_p ? t_reload : -1;
|
rld[s_reload].secondary_in_icode = in_p ? t_icode : CODE_FOR_nothing;
|
rld[s_reload].secondary_in_icode = in_p ? t_icode : CODE_FOR_nothing;
|
rld[s_reload].secondary_out_icode
|
rld[s_reload].secondary_out_icode
|
= ! in_p ? t_icode : CODE_FOR_nothing;
|
= ! in_p ? t_icode : CODE_FOR_nothing;
|
rld[s_reload].secondary_p = 1;
|
rld[s_reload].secondary_p = 1;
|
|
|
n_reloads++;
|
n_reloads++;
|
|
|
#ifdef SECONDARY_MEMORY_NEEDED
|
#ifdef SECONDARY_MEMORY_NEEDED
|
if (! in_p && icode == CODE_FOR_nothing
|
if (! in_p && icode == CODE_FOR_nothing
|
&& SECONDARY_MEMORY_NEEDED (reload_class, class, mode))
|
&& SECONDARY_MEMORY_NEEDED (reload_class, class, mode))
|
get_secondary_mem (x, mode, opnum, type);
|
get_secondary_mem (x, mode, opnum, type);
|
#endif
|
#endif
|
}
|
}
|
|
|
*picode = icode;
|
*picode = icode;
|
return s_reload;
|
return s_reload;
|
}
|
}
|
|
|
/* If a secondary reload is needed, return its class. If both an intermediate
|
/* If a secondary reload is needed, return its class. If both an intermediate
|
register and a scratch register is needed, we return the class of the
|
register and a scratch register is needed, we return the class of the
|
intermediate register. */
|
intermediate register. */
|
enum reg_class
|
enum reg_class
|
secondary_reload_class (bool in_p, enum reg_class class,
|
secondary_reload_class (bool in_p, enum reg_class class,
|
enum machine_mode mode, rtx x)
|
enum machine_mode mode, rtx x)
|
{
|
{
|
enum insn_code icode;
|
enum insn_code icode;
|
secondary_reload_info sri;
|
secondary_reload_info sri;
|
|
|
sri.icode = CODE_FOR_nothing;
|
sri.icode = CODE_FOR_nothing;
|
sri.prev_sri = NULL;
|
sri.prev_sri = NULL;
|
class = targetm.secondary_reload (in_p, x, class, mode, &sri);
|
class = targetm.secondary_reload (in_p, x, class, mode, &sri);
|
icode = sri.icode;
|
icode = sri.icode;
|
|
|
/* If there are no secondary reloads at all, we return NO_REGS.
|
/* If there are no secondary reloads at all, we return NO_REGS.
|
If an intermediate register is needed, we return its class. */
|
If an intermediate register is needed, we return its class. */
|
if (icode == CODE_FOR_nothing || class != NO_REGS)
|
if (icode == CODE_FOR_nothing || class != NO_REGS)
|
return class;
|
return class;
|
|
|
/* No intermediate register is needed, but we have a special reload
|
/* No intermediate register is needed, but we have a special reload
|
pattern, which we assume for now needs a scratch register. */
|
pattern, which we assume for now needs a scratch register. */
|
return scratch_reload_class (icode);
|
return scratch_reload_class (icode);
|
}
|
}
|
|
|
/* ICODE is the insn_code of a reload pattern. Check that it has exactly
|
/* ICODE is the insn_code of a reload pattern. Check that it has exactly
|
three operands, verify that operand 2 is an output operand, and return
|
three operands, verify that operand 2 is an output operand, and return
|
its register class.
|
its register class.
|
??? We'd like to be able to handle any pattern with at least 2 operands,
|
??? We'd like to be able to handle any pattern with at least 2 operands,
|
for zero or more scratch registers, but that needs more infrastructure. */
|
for zero or more scratch registers, but that needs more infrastructure. */
|
enum reg_class
|
enum reg_class
|
scratch_reload_class (enum insn_code icode)
|
scratch_reload_class (enum insn_code icode)
|
{
|
{
|
const char *scratch_constraint;
|
const char *scratch_constraint;
|
char scratch_letter;
|
char scratch_letter;
|
enum reg_class class;
|
enum reg_class class;
|
|
|
gcc_assert (insn_data[(int) icode].n_operands == 3);
|
gcc_assert (insn_data[(int) icode].n_operands == 3);
|
scratch_constraint = insn_data[(int) icode].operand[2].constraint;
|
scratch_constraint = insn_data[(int) icode].operand[2].constraint;
|
gcc_assert (*scratch_constraint == '=');
|
gcc_assert (*scratch_constraint == '=');
|
scratch_constraint++;
|
scratch_constraint++;
|
if (*scratch_constraint == '&')
|
if (*scratch_constraint == '&')
|
scratch_constraint++;
|
scratch_constraint++;
|
scratch_letter = *scratch_constraint;
|
scratch_letter = *scratch_constraint;
|
if (scratch_letter == 'r')
|
if (scratch_letter == 'r')
|
return GENERAL_REGS;
|
return GENERAL_REGS;
|
class = REG_CLASS_FROM_CONSTRAINT ((unsigned char) scratch_letter,
|
class = REG_CLASS_FROM_CONSTRAINT ((unsigned char) scratch_letter,
|
scratch_constraint);
|
scratch_constraint);
|
gcc_assert (class != NO_REGS);
|
gcc_assert (class != NO_REGS);
|
return class;
|
return class;
|
}
|
}
|
|
|
#ifdef SECONDARY_MEMORY_NEEDED
|
#ifdef SECONDARY_MEMORY_NEEDED
|
|
|
/* Return a memory location that will be used to copy X in mode MODE.
|
/* Return a memory location that will be used to copy X in mode MODE.
|
If we haven't already made a location for this mode in this insn,
|
If we haven't already made a location for this mode in this insn,
|
call find_reloads_address on the location being returned. */
|
call find_reloads_address on the location being returned. */
|
|
|
rtx
|
rtx
|
get_secondary_mem (rtx x ATTRIBUTE_UNUSED, enum machine_mode mode,
|
get_secondary_mem (rtx x ATTRIBUTE_UNUSED, enum machine_mode mode,
|
int opnum, enum reload_type type)
|
int opnum, enum reload_type type)
|
{
|
{
|
rtx loc;
|
rtx loc;
|
int mem_valid;
|
int mem_valid;
|
|
|
/* By default, if MODE is narrower than a word, widen it to a word.
|
/* By default, if MODE is narrower than a word, widen it to a word.
|
This is required because most machines that require these memory
|
This is required because most machines that require these memory
|
locations do not support short load and stores from all registers
|
locations do not support short load and stores from all registers
|
(e.g., FP registers). */
|
(e.g., FP registers). */
|
|
|
#ifdef SECONDARY_MEMORY_NEEDED_MODE
|
#ifdef SECONDARY_MEMORY_NEEDED_MODE
|
mode = SECONDARY_MEMORY_NEEDED_MODE (mode);
|
mode = SECONDARY_MEMORY_NEEDED_MODE (mode);
|
#else
|
#else
|
if (GET_MODE_BITSIZE (mode) < BITS_PER_WORD && INTEGRAL_MODE_P (mode))
|
if (GET_MODE_BITSIZE (mode) < BITS_PER_WORD && INTEGRAL_MODE_P (mode))
|
mode = mode_for_size (BITS_PER_WORD, GET_MODE_CLASS (mode), 0);
|
mode = mode_for_size (BITS_PER_WORD, GET_MODE_CLASS (mode), 0);
|
#endif
|
#endif
|
|
|
/* If we already have made a MEM for this operand in MODE, return it. */
|
/* If we already have made a MEM for this operand in MODE, return it. */
|
if (secondary_memlocs_elim[(int) mode][opnum] != 0)
|
if (secondary_memlocs_elim[(int) mode][opnum] != 0)
|
return secondary_memlocs_elim[(int) mode][opnum];
|
return secondary_memlocs_elim[(int) mode][opnum];
|
|
|
/* If this is the first time we've tried to get a MEM for this mode,
|
/* If this is the first time we've tried to get a MEM for this mode,
|
allocate a new one. `something_changed' in reload will get set
|
allocate a new one. `something_changed' in reload will get set
|
by noticing that the frame size has changed. */
|
by noticing that the frame size has changed. */
|
|
|
if (secondary_memlocs[(int) mode] == 0)
|
if (secondary_memlocs[(int) mode] == 0)
|
{
|
{
|
#ifdef SECONDARY_MEMORY_NEEDED_RTX
|
#ifdef SECONDARY_MEMORY_NEEDED_RTX
|
secondary_memlocs[(int) mode] = SECONDARY_MEMORY_NEEDED_RTX (mode);
|
secondary_memlocs[(int) mode] = SECONDARY_MEMORY_NEEDED_RTX (mode);
|
#else
|
#else
|
secondary_memlocs[(int) mode]
|
secondary_memlocs[(int) mode]
|
= assign_stack_local (mode, GET_MODE_SIZE (mode), 0);
|
= assign_stack_local (mode, GET_MODE_SIZE (mode), 0);
|
#endif
|
#endif
|
}
|
}
|
|
|
/* Get a version of the address doing any eliminations needed. If that
|
/* Get a version of the address doing any eliminations needed. If that
|
didn't give us a new MEM, make a new one if it isn't valid. */
|
didn't give us a new MEM, make a new one if it isn't valid. */
|
|
|
loc = eliminate_regs (secondary_memlocs[(int) mode], VOIDmode, NULL_RTX);
|
loc = eliminate_regs (secondary_memlocs[(int) mode], VOIDmode, NULL_RTX);
|
mem_valid = strict_memory_address_p (mode, XEXP (loc, 0));
|
mem_valid = strict_memory_address_p (mode, XEXP (loc, 0));
|
|
|
if (! mem_valid && loc == secondary_memlocs[(int) mode])
|
if (! mem_valid && loc == secondary_memlocs[(int) mode])
|
loc = copy_rtx (loc);
|
loc = copy_rtx (loc);
|
|
|
/* The only time the call below will do anything is if the stack
|
/* The only time the call below will do anything is if the stack
|
offset is too large. In that case IND_LEVELS doesn't matter, so we
|
offset is too large. In that case IND_LEVELS doesn't matter, so we
|
can just pass a zero. Adjust the type to be the address of the
|
can just pass a zero. Adjust the type to be the address of the
|
corresponding object. If the address was valid, save the eliminated
|
corresponding object. If the address was valid, save the eliminated
|
address. If it wasn't valid, we need to make a reload each time, so
|
address. If it wasn't valid, we need to make a reload each time, so
|
don't save it. */
|
don't save it. */
|
|
|
if (! mem_valid)
|
if (! mem_valid)
|
{
|
{
|
type = (type == RELOAD_FOR_INPUT ? RELOAD_FOR_INPUT_ADDRESS
|
type = (type == RELOAD_FOR_INPUT ? RELOAD_FOR_INPUT_ADDRESS
|
: type == RELOAD_FOR_OUTPUT ? RELOAD_FOR_OUTPUT_ADDRESS
|
: type == RELOAD_FOR_OUTPUT ? RELOAD_FOR_OUTPUT_ADDRESS
|
: RELOAD_OTHER);
|
: RELOAD_OTHER);
|
|
|
find_reloads_address (mode, &loc, XEXP (loc, 0), &XEXP (loc, 0),
|
find_reloads_address (mode, &loc, XEXP (loc, 0), &XEXP (loc, 0),
|
opnum, type, 0, 0);
|
opnum, type, 0, 0);
|
}
|
}
|
|
|
secondary_memlocs_elim[(int) mode][opnum] = loc;
|
secondary_memlocs_elim[(int) mode][opnum] = loc;
|
if (secondary_memlocs_elim_used <= (int)mode)
|
if (secondary_memlocs_elim_used <= (int)mode)
|
secondary_memlocs_elim_used = (int)mode + 1;
|
secondary_memlocs_elim_used = (int)mode + 1;
|
return loc;
|
return loc;
|
}
|
}
|
|
|
/* Clear any secondary memory locations we've made. */
|
/* Clear any secondary memory locations we've made. */
|
|
|
void
|
void
|
clear_secondary_mem (void)
|
clear_secondary_mem (void)
|
{
|
{
|
memset (secondary_memlocs, 0, sizeof secondary_memlocs);
|
memset (secondary_memlocs, 0, sizeof secondary_memlocs);
|
}
|
}
|
#endif /* SECONDARY_MEMORY_NEEDED */
|
#endif /* SECONDARY_MEMORY_NEEDED */
|
|
|
|
|
/* Find the largest class which has at least one register valid in
|
/* Find the largest class which has at least one register valid in
|
mode INNER, and which for every such register, that register number
|
mode INNER, and which for every such register, that register number
|
plus N is also valid in OUTER (if in range) and is cheap to move
|
plus N is also valid in OUTER (if in range) and is cheap to move
|
into REGNO. Such a class must exist. */
|
into REGNO. Such a class must exist. */
|
|
|
static enum reg_class
|
static enum reg_class
|
find_valid_class (enum machine_mode outer ATTRIBUTE_UNUSED,
|
find_valid_class (enum machine_mode outer ATTRIBUTE_UNUSED,
|
enum machine_mode inner ATTRIBUTE_UNUSED, int n,
|
enum machine_mode inner ATTRIBUTE_UNUSED, int n,
|
unsigned int dest_regno ATTRIBUTE_UNUSED)
|
unsigned int dest_regno ATTRIBUTE_UNUSED)
|
{
|
{
|
int best_cost = -1;
|
int best_cost = -1;
|
int class;
|
int class;
|
int regno;
|
int regno;
|
enum reg_class best_class = NO_REGS;
|
enum reg_class best_class = NO_REGS;
|
enum reg_class dest_class ATTRIBUTE_UNUSED = REGNO_REG_CLASS (dest_regno);
|
enum reg_class dest_class ATTRIBUTE_UNUSED = REGNO_REG_CLASS (dest_regno);
|
unsigned int best_size = 0;
|
unsigned int best_size = 0;
|
int cost;
|
int cost;
|
|
|
for (class = 1; class < N_REG_CLASSES; class++)
|
for (class = 1; class < N_REG_CLASSES; class++)
|
{
|
{
|
int bad = 0;
|
int bad = 0;
|
int good = 0;
|
int good = 0;
|
for (regno = 0; regno < FIRST_PSEUDO_REGISTER - n && ! bad; regno++)
|
for (regno = 0; regno < FIRST_PSEUDO_REGISTER - n && ! bad; regno++)
|
if (TEST_HARD_REG_BIT (reg_class_contents[class], regno))
|
if (TEST_HARD_REG_BIT (reg_class_contents[class], regno))
|
{
|
{
|
if (HARD_REGNO_MODE_OK (regno, inner))
|
if (HARD_REGNO_MODE_OK (regno, inner))
|
{
|
{
|
good = 1;
|
good = 1;
|
if (! TEST_HARD_REG_BIT (reg_class_contents[class], regno + n)
|
if (! TEST_HARD_REG_BIT (reg_class_contents[class], regno + n)
|
|| ! HARD_REGNO_MODE_OK (regno + n, outer))
|
|| ! HARD_REGNO_MODE_OK (regno + n, outer))
|
bad = 1;
|
bad = 1;
|
}
|
}
|
}
|
}
|
|
|
if (bad || !good)
|
if (bad || !good)
|
continue;
|
continue;
|
cost = REGISTER_MOVE_COST (outer, class, dest_class);
|
cost = REGISTER_MOVE_COST (outer, class, dest_class);
|
|
|
if ((reg_class_size[class] > best_size
|
if ((reg_class_size[class] > best_size
|
&& (best_cost < 0 || best_cost >= cost))
|
&& (best_cost < 0 || best_cost >= cost))
|
|| best_cost > cost)
|
|| best_cost > cost)
|
{
|
{
|
best_class = class;
|
best_class = class;
|
best_size = reg_class_size[class];
|
best_size = reg_class_size[class];
|
best_cost = REGISTER_MOVE_COST (outer, class, dest_class);
|
best_cost = REGISTER_MOVE_COST (outer, class, dest_class);
|
}
|
}
|
}
|
}
|
|
|
gcc_assert (best_size != 0);
|
gcc_assert (best_size != 0);
|
|
|
return best_class;
|
return best_class;
|
}
|
}
|
|
|
/* Return the number of a previously made reload that can be combined with
|
/* Return the number of a previously made reload that can be combined with
|
a new one, or n_reloads if none of the existing reloads can be used.
|
a new one, or n_reloads if none of the existing reloads can be used.
|
OUT, CLASS, TYPE and OPNUM are the same arguments as passed to
|
OUT, CLASS, TYPE and OPNUM are the same arguments as passed to
|
push_reload, they determine the kind of the new reload that we try to
|
push_reload, they determine the kind of the new reload that we try to
|
combine. P_IN points to the corresponding value of IN, which can be
|
combine. P_IN points to the corresponding value of IN, which can be
|
modified by this function.
|
modified by this function.
|
DONT_SHARE is nonzero if we can't share any input-only reload for IN. */
|
DONT_SHARE is nonzero if we can't share any input-only reload for IN. */
|
|
|
static int
|
static int
|
find_reusable_reload (rtx *p_in, rtx out, enum reg_class class,
|
find_reusable_reload (rtx *p_in, rtx out, enum reg_class class,
|
enum reload_type type, int opnum, int dont_share)
|
enum reload_type type, int opnum, int dont_share)
|
{
|
{
|
rtx in = *p_in;
|
rtx in = *p_in;
|
int i;
|
int i;
|
/* We can't merge two reloads if the output of either one is
|
/* We can't merge two reloads if the output of either one is
|
earlyclobbered. */
|
earlyclobbered. */
|
|
|
if (earlyclobber_operand_p (out))
|
if (earlyclobber_operand_p (out))
|
return n_reloads;
|
return n_reloads;
|
|
|
/* We can use an existing reload if the class is right
|
/* We can use an existing reload if the class is right
|
and at least one of IN and OUT is a match
|
and at least one of IN and OUT is a match
|
and the other is at worst neutral.
|
and the other is at worst neutral.
|
(A zero compared against anything is neutral.)
|
(A zero compared against anything is neutral.)
|
|
|
If SMALL_REGISTER_CLASSES, don't use existing reloads unless they are
|
If SMALL_REGISTER_CLASSES, don't use existing reloads unless they are
|
for the same thing since that can cause us to need more reload registers
|
for the same thing since that can cause us to need more reload registers
|
than we otherwise would. */
|
than we otherwise would. */
|
|
|
for (i = 0; i < n_reloads; i++)
|
for (i = 0; i < n_reloads; i++)
|
if ((reg_class_subset_p (class, rld[i].class)
|
if ((reg_class_subset_p (class, rld[i].class)
|
|| reg_class_subset_p (rld[i].class, class))
|
|| reg_class_subset_p (rld[i].class, class))
|
/* If the existing reload has a register, it must fit our class. */
|
/* If the existing reload has a register, it must fit our class. */
|
&& (rld[i].reg_rtx == 0
|
&& (rld[i].reg_rtx == 0
|
|| TEST_HARD_REG_BIT (reg_class_contents[(int) class],
|
|| TEST_HARD_REG_BIT (reg_class_contents[(int) class],
|
true_regnum (rld[i].reg_rtx)))
|
true_regnum (rld[i].reg_rtx)))
|
&& ((in != 0 && MATCHES (rld[i].in, in) && ! dont_share
|
&& ((in != 0 && MATCHES (rld[i].in, in) && ! dont_share
|
&& (out == 0 || rld[i].out == 0 || MATCHES (rld[i].out, out)))
|
&& (out == 0 || rld[i].out == 0 || MATCHES (rld[i].out, out)))
|
|| (out != 0 && MATCHES (rld[i].out, out)
|
|| (out != 0 && MATCHES (rld[i].out, out)
|
&& (in == 0 || rld[i].in == 0 || MATCHES (rld[i].in, in))))
|
&& (in == 0 || rld[i].in == 0 || MATCHES (rld[i].in, in))))
|
&& (rld[i].out == 0 || ! earlyclobber_operand_p (rld[i].out))
|
&& (rld[i].out == 0 || ! earlyclobber_operand_p (rld[i].out))
|
&& (SMALL_REGISTER_CLASS_P (class) || SMALL_REGISTER_CLASSES)
|
&& (SMALL_REGISTER_CLASS_P (class) || SMALL_REGISTER_CLASSES)
|
&& MERGABLE_RELOADS (type, rld[i].when_needed, opnum, rld[i].opnum))
|
&& MERGABLE_RELOADS (type, rld[i].when_needed, opnum, rld[i].opnum))
|
return i;
|
return i;
|
|
|
/* Reloading a plain reg for input can match a reload to postincrement
|
/* Reloading a plain reg for input can match a reload to postincrement
|
that reg, since the postincrement's value is the right value.
|
that reg, since the postincrement's value is the right value.
|
Likewise, it can match a preincrement reload, since we regard
|
Likewise, it can match a preincrement reload, since we regard
|
the preincrementation as happening before any ref in this insn
|
the preincrementation as happening before any ref in this insn
|
to that register. */
|
to that register. */
|
for (i = 0; i < n_reloads; i++)
|
for (i = 0; i < n_reloads; i++)
|
if ((reg_class_subset_p (class, rld[i].class)
|
if ((reg_class_subset_p (class, rld[i].class)
|
|| reg_class_subset_p (rld[i].class, class))
|
|| reg_class_subset_p (rld[i].class, class))
|
/* If the existing reload has a register, it must fit our
|
/* If the existing reload has a register, it must fit our
|
class. */
|
class. */
|
&& (rld[i].reg_rtx == 0
|
&& (rld[i].reg_rtx == 0
|
|| TEST_HARD_REG_BIT (reg_class_contents[(int) class],
|
|| TEST_HARD_REG_BIT (reg_class_contents[(int) class],
|
true_regnum (rld[i].reg_rtx)))
|
true_regnum (rld[i].reg_rtx)))
|
&& out == 0 && rld[i].out == 0 && rld[i].in != 0
|
&& out == 0 && rld[i].out == 0 && rld[i].in != 0
|
&& ((REG_P (in)
|
&& ((REG_P (in)
|
&& GET_RTX_CLASS (GET_CODE (rld[i].in)) == RTX_AUTOINC
|
&& GET_RTX_CLASS (GET_CODE (rld[i].in)) == RTX_AUTOINC
|
&& MATCHES (XEXP (rld[i].in, 0), in))
|
&& MATCHES (XEXP (rld[i].in, 0), in))
|
|| (REG_P (rld[i].in)
|
|| (REG_P (rld[i].in)
|
&& GET_RTX_CLASS (GET_CODE (in)) == RTX_AUTOINC
|
&& GET_RTX_CLASS (GET_CODE (in)) == RTX_AUTOINC
|
&& MATCHES (XEXP (in, 0), rld[i].in)))
|
&& MATCHES (XEXP (in, 0), rld[i].in)))
|
&& (rld[i].out == 0 || ! earlyclobber_operand_p (rld[i].out))
|
&& (rld[i].out == 0 || ! earlyclobber_operand_p (rld[i].out))
|
&& (SMALL_REGISTER_CLASS_P (class) || SMALL_REGISTER_CLASSES)
|
&& (SMALL_REGISTER_CLASS_P (class) || SMALL_REGISTER_CLASSES)
|
&& MERGABLE_RELOADS (type, rld[i].when_needed,
|
&& MERGABLE_RELOADS (type, rld[i].when_needed,
|
opnum, rld[i].opnum))
|
opnum, rld[i].opnum))
|
{
|
{
|
/* Make sure reload_in ultimately has the increment,
|
/* Make sure reload_in ultimately has the increment,
|
not the plain register. */
|
not the plain register. */
|
if (REG_P (in))
|
if (REG_P (in))
|
*p_in = rld[i].in;
|
*p_in = rld[i].in;
|
return i;
|
return i;
|
}
|
}
|
return n_reloads;
|
return n_reloads;
|
}
|
}
|
|
|
/* Return nonzero if X is a SUBREG which will require reloading of its
|
/* Return nonzero if X is a SUBREG which will require reloading of its
|
SUBREG_REG expression. */
|
SUBREG_REG expression. */
|
|
|
static int
|
static int
|
reload_inner_reg_of_subreg (rtx x, enum machine_mode mode, int output)
|
reload_inner_reg_of_subreg (rtx x, enum machine_mode mode, int output)
|
{
|
{
|
rtx inner;
|
rtx inner;
|
|
|
/* Only SUBREGs are problematical. */
|
/* Only SUBREGs are problematical. */
|
if (GET_CODE (x) != SUBREG)
|
if (GET_CODE (x) != SUBREG)
|
return 0;
|
return 0;
|
|
|
inner = SUBREG_REG (x);
|
inner = SUBREG_REG (x);
|
|
|
/* If INNER is a constant or PLUS, then INNER must be reloaded. */
|
/* If INNER is a constant or PLUS, then INNER must be reloaded. */
|
if (CONSTANT_P (inner) || GET_CODE (inner) == PLUS)
|
if (CONSTANT_P (inner) || GET_CODE (inner) == PLUS)
|
return 1;
|
return 1;
|
|
|
/* If INNER is not a hard register, then INNER will not need to
|
/* If INNER is not a hard register, then INNER will not need to
|
be reloaded. */
|
be reloaded. */
|
if (!REG_P (inner)
|
if (!REG_P (inner)
|
|| REGNO (inner) >= FIRST_PSEUDO_REGISTER)
|
|| REGNO (inner) >= FIRST_PSEUDO_REGISTER)
|
return 0;
|
return 0;
|
|
|
/* If INNER is not ok for MODE, then INNER will need reloading. */
|
/* If INNER is not ok for MODE, then INNER will need reloading. */
|
if (! HARD_REGNO_MODE_OK (subreg_regno (x), mode))
|
if (! HARD_REGNO_MODE_OK (subreg_regno (x), mode))
|
return 1;
|
return 1;
|
|
|
/* If the outer part is a word or smaller, INNER larger than a
|
/* If the outer part is a word or smaller, INNER larger than a
|
word and the number of regs for INNER is not the same as the
|
word and the number of regs for INNER is not the same as the
|
number of words in INNER, then INNER will need reloading. */
|
number of words in INNER, then INNER will need reloading. */
|
return (GET_MODE_SIZE (mode) <= UNITS_PER_WORD
|
return (GET_MODE_SIZE (mode) <= UNITS_PER_WORD
|
&& output
|
&& output
|
&& GET_MODE_SIZE (GET_MODE (inner)) > UNITS_PER_WORD
|
&& GET_MODE_SIZE (GET_MODE (inner)) > UNITS_PER_WORD
|
&& ((GET_MODE_SIZE (GET_MODE (inner)) / UNITS_PER_WORD)
|
&& ((GET_MODE_SIZE (GET_MODE (inner)) / UNITS_PER_WORD)
|
!= (int) hard_regno_nregs[REGNO (inner)][GET_MODE (inner)]));
|
!= (int) hard_regno_nregs[REGNO (inner)][GET_MODE (inner)]));
|
}
|
}
|
|
|
/* Return nonzero if IN can be reloaded into REGNO with mode MODE without
|
/* Return nonzero if IN can be reloaded into REGNO with mode MODE without
|
requiring an extra reload register. The caller has already found that
|
requiring an extra reload register. The caller has already found that
|
IN contains some reference to REGNO, so check that we can produce the
|
IN contains some reference to REGNO, so check that we can produce the
|
new value in a single step. E.g. if we have
|
new value in a single step. E.g. if we have
|
(set (reg r13) (plus (reg r13) (const int 1))), and there is an
|
(set (reg r13) (plus (reg r13) (const int 1))), and there is an
|
instruction that adds one to a register, this should succeed.
|
instruction that adds one to a register, this should succeed.
|
However, if we have something like
|
However, if we have something like
|
(set (reg r13) (plus (reg r13) (const int 999))), and the constant 999
|
(set (reg r13) (plus (reg r13) (const int 999))), and the constant 999
|
needs to be loaded into a register first, we need a separate reload
|
needs to be loaded into a register first, we need a separate reload
|
register.
|
register.
|
Such PLUS reloads are generated by find_reload_address_part.
|
Such PLUS reloads are generated by find_reload_address_part.
|
The out-of-range PLUS expressions are usually introduced in the instruction
|
The out-of-range PLUS expressions are usually introduced in the instruction
|
patterns by register elimination and substituting pseudos without a home
|
patterns by register elimination and substituting pseudos without a home
|
by their function-invariant equivalences. */
|
by their function-invariant equivalences. */
|
static int
|
static int
|
can_reload_into (rtx in, int regno, enum machine_mode mode)
|
can_reload_into (rtx in, int regno, enum machine_mode mode)
|
{
|
{
|
rtx dst, test_insn;
|
rtx dst, test_insn;
|
int r = 0;
|
int r = 0;
|
struct recog_data save_recog_data;
|
struct recog_data save_recog_data;
|
|
|
/* For matching constraints, we often get notional input reloads where
|
/* For matching constraints, we often get notional input reloads where
|
we want to use the original register as the reload register. I.e.
|
we want to use the original register as the reload register. I.e.
|
technically this is a non-optional input-output reload, but IN is
|
technically this is a non-optional input-output reload, but IN is
|
already a valid register, and has been chosen as the reload register.
|
already a valid register, and has been chosen as the reload register.
|
Speed this up, since it trivially works. */
|
Speed this up, since it trivially works. */
|
if (REG_P (in))
|
if (REG_P (in))
|
return 1;
|
return 1;
|
|
|
/* To test MEMs properly, we'd have to take into account all the reloads
|
/* To test MEMs properly, we'd have to take into account all the reloads
|
that are already scheduled, which can become quite complicated.
|
that are already scheduled, which can become quite complicated.
|
And since we've already handled address reloads for this MEM, it
|
And since we've already handled address reloads for this MEM, it
|
should always succeed anyway. */
|
should always succeed anyway. */
|
if (MEM_P (in))
|
if (MEM_P (in))
|
return 1;
|
return 1;
|
|
|
/* If we can make a simple SET insn that does the job, everything should
|
/* If we can make a simple SET insn that does the job, everything should
|
be fine. */
|
be fine. */
|
dst = gen_rtx_REG (mode, regno);
|
dst = gen_rtx_REG (mode, regno);
|
test_insn = make_insn_raw (gen_rtx_SET (VOIDmode, dst, in));
|
test_insn = make_insn_raw (gen_rtx_SET (VOIDmode, dst, in));
|
save_recog_data = recog_data;
|
save_recog_data = recog_data;
|
if (recog_memoized (test_insn) >= 0)
|
if (recog_memoized (test_insn) >= 0)
|
{
|
{
|
extract_insn (test_insn);
|
extract_insn (test_insn);
|
r = constrain_operands (1);
|
r = constrain_operands (1);
|
}
|
}
|
recog_data = save_recog_data;
|
recog_data = save_recog_data;
|
return r;
|
return r;
|
}
|
}
|
|
|
/* Record one reload that needs to be performed.
|
/* Record one reload that needs to be performed.
|
IN is an rtx saying where the data are to be found before this instruction.
|
IN is an rtx saying where the data are to be found before this instruction.
|
OUT says where they must be stored after the instruction.
|
OUT says where they must be stored after the instruction.
|
(IN is zero for data not read, and OUT is zero for data not written.)
|
(IN is zero for data not read, and OUT is zero for data not written.)
|
INLOC and OUTLOC point to the places in the instructions where
|
INLOC and OUTLOC point to the places in the instructions where
|
IN and OUT were found.
|
IN and OUT were found.
|
If IN and OUT are both nonzero, it means the same register must be used
|
If IN and OUT are both nonzero, it means the same register must be used
|
to reload both IN and OUT.
|
to reload both IN and OUT.
|
|
|
CLASS is a register class required for the reloaded data.
|
CLASS is a register class required for the reloaded data.
|
INMODE is the machine mode that the instruction requires
|
INMODE is the machine mode that the instruction requires
|
for the reg that replaces IN and OUTMODE is likewise for OUT.
|
for the reg that replaces IN and OUTMODE is likewise for OUT.
|
|
|
If IN is zero, then OUT's location and mode should be passed as
|
If IN is zero, then OUT's location and mode should be passed as
|
INLOC and INMODE.
|
INLOC and INMODE.
|
|
|
STRICT_LOW is the 1 if there is a containing STRICT_LOW_PART rtx.
|
STRICT_LOW is the 1 if there is a containing STRICT_LOW_PART rtx.
|
|
|
OPTIONAL nonzero means this reload does not need to be performed:
|
OPTIONAL nonzero means this reload does not need to be performed:
|
it can be discarded if that is more convenient.
|
it can be discarded if that is more convenient.
|
|
|
OPNUM and TYPE say what the purpose of this reload is.
|
OPNUM and TYPE say what the purpose of this reload is.
|
|
|
The return value is the reload-number for this reload.
|
The return value is the reload-number for this reload.
|
|
|
If both IN and OUT are nonzero, in some rare cases we might
|
If both IN and OUT are nonzero, in some rare cases we might
|
want to make two separate reloads. (Actually we never do this now.)
|
want to make two separate reloads. (Actually we never do this now.)
|
Therefore, the reload-number for OUT is stored in
|
Therefore, the reload-number for OUT is stored in
|
output_reloadnum when we return; the return value applies to IN.
|
output_reloadnum when we return; the return value applies to IN.
|
Usually (presently always), when IN and OUT are nonzero,
|
Usually (presently always), when IN and OUT are nonzero,
|
the two reload-numbers are equal, but the caller should be careful to
|
the two reload-numbers are equal, but the caller should be careful to
|
distinguish them. */
|
distinguish them. */
|
|
|
int
|
int
|
push_reload (rtx in, rtx out, rtx *inloc, rtx *outloc,
|
push_reload (rtx in, rtx out, rtx *inloc, rtx *outloc,
|
enum reg_class class, enum machine_mode inmode,
|
enum reg_class class, enum machine_mode inmode,
|
enum machine_mode outmode, int strict_low, int optional,
|
enum machine_mode outmode, int strict_low, int optional,
|
int opnum, enum reload_type type)
|
int opnum, enum reload_type type)
|
{
|
{
|
int i;
|
int i;
|
int dont_share = 0;
|
int dont_share = 0;
|
int dont_remove_subreg = 0;
|
int dont_remove_subreg = 0;
|
rtx *in_subreg_loc = 0, *out_subreg_loc = 0;
|
rtx *in_subreg_loc = 0, *out_subreg_loc = 0;
|
int secondary_in_reload = -1, secondary_out_reload = -1;
|
int secondary_in_reload = -1, secondary_out_reload = -1;
|
enum insn_code secondary_in_icode = CODE_FOR_nothing;
|
enum insn_code secondary_in_icode = CODE_FOR_nothing;
|
enum insn_code secondary_out_icode = CODE_FOR_nothing;
|
enum insn_code secondary_out_icode = CODE_FOR_nothing;
|
|
|
/* INMODE and/or OUTMODE could be VOIDmode if no mode
|
/* INMODE and/or OUTMODE could be VOIDmode if no mode
|
has been specified for the operand. In that case,
|
has been specified for the operand. In that case,
|
use the operand's mode as the mode to reload. */
|
use the operand's mode as the mode to reload. */
|
if (inmode == VOIDmode && in != 0)
|
if (inmode == VOIDmode && in != 0)
|
inmode = GET_MODE (in);
|
inmode = GET_MODE (in);
|
if (outmode == VOIDmode && out != 0)
|
if (outmode == VOIDmode && out != 0)
|
outmode = GET_MODE (out);
|
outmode = GET_MODE (out);
|
|
|
/* If IN is a pseudo register everywhere-equivalent to a constant, and
|
/* If IN is a pseudo register everywhere-equivalent to a constant, and
|
it is not in a hard register, reload straight from the constant,
|
it is not in a hard register, reload straight from the constant,
|
since we want to get rid of such pseudo registers.
|
since we want to get rid of such pseudo registers.
|
Often this is done earlier, but not always in find_reloads_address. */
|
Often this is done earlier, but not always in find_reloads_address. */
|
if (in != 0 && REG_P (in))
|
if (in != 0 && REG_P (in))
|
{
|
{
|
int regno = REGNO (in);
|
int regno = REGNO (in);
|
|
|
if (regno >= FIRST_PSEUDO_REGISTER && reg_renumber[regno] < 0
|
if (regno >= FIRST_PSEUDO_REGISTER && reg_renumber[regno] < 0
|
&& reg_equiv_constant[regno] != 0)
|
&& reg_equiv_constant[regno] != 0)
|
in = reg_equiv_constant[regno];
|
in = reg_equiv_constant[regno];
|
}
|
}
|
|
|
/* Likewise for OUT. Of course, OUT will never be equivalent to
|
/* Likewise for OUT. Of course, OUT will never be equivalent to
|
an actual constant, but it might be equivalent to a memory location
|
an actual constant, but it might be equivalent to a memory location
|
(in the case of a parameter). */
|
(in the case of a parameter). */
|
if (out != 0 && REG_P (out))
|
if (out != 0 && REG_P (out))
|
{
|
{
|
int regno = REGNO (out);
|
int regno = REGNO (out);
|
|
|
if (regno >= FIRST_PSEUDO_REGISTER && reg_renumber[regno] < 0
|
if (regno >= FIRST_PSEUDO_REGISTER && reg_renumber[regno] < 0
|
&& reg_equiv_constant[regno] != 0)
|
&& reg_equiv_constant[regno] != 0)
|
out = reg_equiv_constant[regno];
|
out = reg_equiv_constant[regno];
|
}
|
}
|
|
|
/* If we have a read-write operand with an address side-effect,
|
/* If we have a read-write operand with an address side-effect,
|
change either IN or OUT so the side-effect happens only once. */
|
change either IN or OUT so the side-effect happens only once. */
|
if (in != 0 && out != 0 && MEM_P (in) && rtx_equal_p (in, out))
|
if (in != 0 && out != 0 && MEM_P (in) && rtx_equal_p (in, out))
|
switch (GET_CODE (XEXP (in, 0)))
|
switch (GET_CODE (XEXP (in, 0)))
|
{
|
{
|
case POST_INC: case POST_DEC: case POST_MODIFY:
|
case POST_INC: case POST_DEC: case POST_MODIFY:
|
in = replace_equiv_address_nv (in, XEXP (XEXP (in, 0), 0));
|
in = replace_equiv_address_nv (in, XEXP (XEXP (in, 0), 0));
|
break;
|
break;
|
|
|
case PRE_INC: case PRE_DEC: case PRE_MODIFY:
|
case PRE_INC: case PRE_DEC: case PRE_MODIFY:
|
out = replace_equiv_address_nv (out, XEXP (XEXP (out, 0), 0));
|
out = replace_equiv_address_nv (out, XEXP (XEXP (out, 0), 0));
|
break;
|
break;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
/* If we are reloading a (SUBREG constant ...), really reload just the
|
/* If we are reloading a (SUBREG constant ...), really reload just the
|
inside expression in its own mode. Similarly for (SUBREG (PLUS ...)).
|
inside expression in its own mode. Similarly for (SUBREG (PLUS ...)).
|
If we have (SUBREG:M1 (MEM:M2 ...) ...) (or an inner REG that is still
|
If we have (SUBREG:M1 (MEM:M2 ...) ...) (or an inner REG that is still
|
a pseudo and hence will become a MEM) with M1 wider than M2 and the
|
a pseudo and hence will become a MEM) with M1 wider than M2 and the
|
register is a pseudo, also reload the inside expression.
|
register is a pseudo, also reload the inside expression.
|
For machines that extend byte loads, do this for any SUBREG of a pseudo
|
For machines that extend byte loads, do this for any SUBREG of a pseudo
|
where both M1 and M2 are a word or smaller, M1 is wider than M2, and
|
where both M1 and M2 are a word or smaller, M1 is wider than M2, and
|
M2 is an integral mode that gets extended when loaded.
|
M2 is an integral mode that gets extended when loaded.
|
Similar issue for (SUBREG:M1 (REG:M2 ...) ...) for a hard register R where
|
Similar issue for (SUBREG:M1 (REG:M2 ...) ...) for a hard register R where
|
either M1 is not valid for R or M2 is wider than a word but we only
|
either M1 is not valid for R or M2 is wider than a word but we only
|
need one word to store an M2-sized quantity in R.
|
need one word to store an M2-sized quantity in R.
|
(However, if OUT is nonzero, we need to reload the reg *and*
|
(However, if OUT is nonzero, we need to reload the reg *and*
|
the subreg, so do nothing here, and let following statement handle it.)
|
the subreg, so do nothing here, and let following statement handle it.)
|
|
|
Note that the case of (SUBREG (CONST_INT...)...) is handled elsewhere;
|
Note that the case of (SUBREG (CONST_INT...)...) is handled elsewhere;
|
we can't handle it here because CONST_INT does not indicate a mode.
|
we can't handle it here because CONST_INT does not indicate a mode.
|
|
|
Similarly, we must reload the inside expression if we have a
|
Similarly, we must reload the inside expression if we have a
|
STRICT_LOW_PART (presumably, in == out in the cas).
|
STRICT_LOW_PART (presumably, in == out in the cas).
|
|
|
Also reload the inner expression if it does not require a secondary
|
Also reload the inner expression if it does not require a secondary
|
reload but the SUBREG does.
|
reload but the SUBREG does.
|
|
|
Finally, reload the inner expression if it is a register that is in
|
Finally, reload the inner expression if it is a register that is in
|
the class whose registers cannot be referenced in a different size
|
the class whose registers cannot be referenced in a different size
|
and M1 is not the same size as M2. If subreg_lowpart_p is false, we
|
and M1 is not the same size as M2. If subreg_lowpart_p is false, we
|
cannot reload just the inside since we might end up with the wrong
|
cannot reload just the inside since we might end up with the wrong
|
register class. But if it is inside a STRICT_LOW_PART, we have
|
register class. But if it is inside a STRICT_LOW_PART, we have
|
no choice, so we hope we do get the right register class there. */
|
no choice, so we hope we do get the right register class there. */
|
|
|
if (in != 0 && GET_CODE (in) == SUBREG
|
if (in != 0 && GET_CODE (in) == SUBREG
|
&& (subreg_lowpart_p (in) || strict_low)
|
&& (subreg_lowpart_p (in) || strict_low)
|
#ifdef CANNOT_CHANGE_MODE_CLASS
|
#ifdef CANNOT_CHANGE_MODE_CLASS
|
&& !CANNOT_CHANGE_MODE_CLASS (GET_MODE (SUBREG_REG (in)), inmode, class)
|
&& !CANNOT_CHANGE_MODE_CLASS (GET_MODE (SUBREG_REG (in)), inmode, class)
|
#endif
|
#endif
|
&& (CONSTANT_P (SUBREG_REG (in))
|
&& (CONSTANT_P (SUBREG_REG (in))
|
|| GET_CODE (SUBREG_REG (in)) == PLUS
|
|| GET_CODE (SUBREG_REG (in)) == PLUS
|
|| strict_low
|
|| strict_low
|
|| (((REG_P (SUBREG_REG (in))
|
|| (((REG_P (SUBREG_REG (in))
|
&& REGNO (SUBREG_REG (in)) >= FIRST_PSEUDO_REGISTER)
|
&& REGNO (SUBREG_REG (in)) >= FIRST_PSEUDO_REGISTER)
|
|| MEM_P (SUBREG_REG (in)))
|
|| MEM_P (SUBREG_REG (in)))
|
&& ((GET_MODE_SIZE (inmode)
|
&& ((GET_MODE_SIZE (inmode)
|
> GET_MODE_SIZE (GET_MODE (SUBREG_REG (in))))
|
> GET_MODE_SIZE (GET_MODE (SUBREG_REG (in))))
|
#ifdef LOAD_EXTEND_OP
|
#ifdef LOAD_EXTEND_OP
|
|| (GET_MODE_SIZE (inmode) <= UNITS_PER_WORD
|
|| (GET_MODE_SIZE (inmode) <= UNITS_PER_WORD
|
&& (GET_MODE_SIZE (GET_MODE (SUBREG_REG (in)))
|
&& (GET_MODE_SIZE (GET_MODE (SUBREG_REG (in)))
|
<= UNITS_PER_WORD)
|
<= UNITS_PER_WORD)
|
&& (GET_MODE_SIZE (inmode)
|
&& (GET_MODE_SIZE (inmode)
|
> GET_MODE_SIZE (GET_MODE (SUBREG_REG (in))))
|
> GET_MODE_SIZE (GET_MODE (SUBREG_REG (in))))
|
&& INTEGRAL_MODE_P (GET_MODE (SUBREG_REG (in)))
|
&& INTEGRAL_MODE_P (GET_MODE (SUBREG_REG (in)))
|
&& LOAD_EXTEND_OP (GET_MODE (SUBREG_REG (in))) != UNKNOWN)
|
&& LOAD_EXTEND_OP (GET_MODE (SUBREG_REG (in))) != UNKNOWN)
|
#endif
|
#endif
|
#ifdef WORD_REGISTER_OPERATIONS
|
#ifdef WORD_REGISTER_OPERATIONS
|
|| ((GET_MODE_SIZE (inmode)
|
|| ((GET_MODE_SIZE (inmode)
|
< GET_MODE_SIZE (GET_MODE (SUBREG_REG (in))))
|
< GET_MODE_SIZE (GET_MODE (SUBREG_REG (in))))
|
&& ((GET_MODE_SIZE (inmode) - 1) / UNITS_PER_WORD ==
|
&& ((GET_MODE_SIZE (inmode) - 1) / UNITS_PER_WORD ==
|
((GET_MODE_SIZE (GET_MODE (SUBREG_REG (in))) - 1)
|
((GET_MODE_SIZE (GET_MODE (SUBREG_REG (in))) - 1)
|
/ UNITS_PER_WORD)))
|
/ UNITS_PER_WORD)))
|
#endif
|
#endif
|
))
|
))
|
|| (REG_P (SUBREG_REG (in))
|
|| (REG_P (SUBREG_REG (in))
|
&& REGNO (SUBREG_REG (in)) < FIRST_PSEUDO_REGISTER
|
&& REGNO (SUBREG_REG (in)) < FIRST_PSEUDO_REGISTER
|
/* The case where out is nonzero
|
/* The case where out is nonzero
|
is handled differently in the following statement. */
|
is handled differently in the following statement. */
|
&& (out == 0 || subreg_lowpart_p (in))
|
&& (out == 0 || subreg_lowpart_p (in))
|
&& ((GET_MODE_SIZE (inmode) <= UNITS_PER_WORD
|
&& ((GET_MODE_SIZE (inmode) <= UNITS_PER_WORD
|
&& (GET_MODE_SIZE (GET_MODE (SUBREG_REG (in)))
|
&& (GET_MODE_SIZE (GET_MODE (SUBREG_REG (in)))
|
> UNITS_PER_WORD)
|
> UNITS_PER_WORD)
|
&& ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (in)))
|
&& ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (in)))
|
/ UNITS_PER_WORD)
|
/ UNITS_PER_WORD)
|
!= (int) hard_regno_nregs[REGNO (SUBREG_REG (in))]
|
!= (int) hard_regno_nregs[REGNO (SUBREG_REG (in))]
|
[GET_MODE (SUBREG_REG (in))]))
|
[GET_MODE (SUBREG_REG (in))]))
|
|| ! HARD_REGNO_MODE_OK (subreg_regno (in), inmode)))
|
|| ! HARD_REGNO_MODE_OK (subreg_regno (in), inmode)))
|
|| (secondary_reload_class (1, class, inmode, in) != NO_REGS
|
|| (secondary_reload_class (1, class, inmode, in) != NO_REGS
|
&& (secondary_reload_class (1, class, GET_MODE (SUBREG_REG (in)),
|
&& (secondary_reload_class (1, class, GET_MODE (SUBREG_REG (in)),
|
SUBREG_REG (in))
|
SUBREG_REG (in))
|
== NO_REGS))
|
== NO_REGS))
|
#ifdef CANNOT_CHANGE_MODE_CLASS
|
#ifdef CANNOT_CHANGE_MODE_CLASS
|
|| (REG_P (SUBREG_REG (in))
|
|| (REG_P (SUBREG_REG (in))
|
&& REGNO (SUBREG_REG (in)) < FIRST_PSEUDO_REGISTER
|
&& REGNO (SUBREG_REG (in)) < FIRST_PSEUDO_REGISTER
|
&& REG_CANNOT_CHANGE_MODE_P
|
&& REG_CANNOT_CHANGE_MODE_P
|
(REGNO (SUBREG_REG (in)), GET_MODE (SUBREG_REG (in)), inmode))
|
(REGNO (SUBREG_REG (in)), GET_MODE (SUBREG_REG (in)), inmode))
|
#endif
|
#endif
|
))
|
))
|
{
|
{
|
in_subreg_loc = inloc;
|
in_subreg_loc = inloc;
|
inloc = &SUBREG_REG (in);
|
inloc = &SUBREG_REG (in);
|
in = *inloc;
|
in = *inloc;
|
#if ! defined (LOAD_EXTEND_OP) && ! defined (WORD_REGISTER_OPERATIONS)
|
#if ! defined (LOAD_EXTEND_OP) && ! defined (WORD_REGISTER_OPERATIONS)
|
if (MEM_P (in))
|
if (MEM_P (in))
|
/* This is supposed to happen only for paradoxical subregs made by
|
/* This is supposed to happen only for paradoxical subregs made by
|
combine.c. (SUBREG (MEM)) isn't supposed to occur other ways. */
|
combine.c. (SUBREG (MEM)) isn't supposed to occur other ways. */
|
gcc_assert (GET_MODE_SIZE (GET_MODE (in)) <= GET_MODE_SIZE (inmode));
|
gcc_assert (GET_MODE_SIZE (GET_MODE (in)) <= GET_MODE_SIZE (inmode));
|
#endif
|
#endif
|
inmode = GET_MODE (in);
|
inmode = GET_MODE (in);
|
}
|
}
|
|
|
/* Similar issue for (SUBREG:M1 (REG:M2 ...) ...) for a hard register R where
|
/* Similar issue for (SUBREG:M1 (REG:M2 ...) ...) for a hard register R where
|
either M1 is not valid for R or M2 is wider than a word but we only
|
either M1 is not valid for R or M2 is wider than a word but we only
|
need one word to store an M2-sized quantity in R.
|
need one word to store an M2-sized quantity in R.
|
|
|
However, we must reload the inner reg *as well as* the subreg in
|
However, we must reload the inner reg *as well as* the subreg in
|
that case. */
|
that case. */
|
|
|
/* Similar issue for (SUBREG constant ...) if it was not handled by the
|
/* Similar issue for (SUBREG constant ...) if it was not handled by the
|
code above. This can happen if SUBREG_BYTE != 0. */
|
code above. This can happen if SUBREG_BYTE != 0. */
|
|
|
if (in != 0 && reload_inner_reg_of_subreg (in, inmode, 0))
|
if (in != 0 && reload_inner_reg_of_subreg (in, inmode, 0))
|
{
|
{
|
enum reg_class in_class = class;
|
enum reg_class in_class = class;
|
|
|
if (REG_P (SUBREG_REG (in)))
|
if (REG_P (SUBREG_REG (in)))
|
in_class
|
in_class
|
= find_valid_class (inmode, GET_MODE (SUBREG_REG (in)),
|
= find_valid_class (inmode, GET_MODE (SUBREG_REG (in)),
|
subreg_regno_offset (REGNO (SUBREG_REG (in)),
|
subreg_regno_offset (REGNO (SUBREG_REG (in)),
|
GET_MODE (SUBREG_REG (in)),
|
GET_MODE (SUBREG_REG (in)),
|
SUBREG_BYTE (in),
|
SUBREG_BYTE (in),
|
GET_MODE (in)),
|
GET_MODE (in)),
|
REGNO (SUBREG_REG (in)));
|
REGNO (SUBREG_REG (in)));
|
|
|
/* This relies on the fact that emit_reload_insns outputs the
|
/* This relies on the fact that emit_reload_insns outputs the
|
instructions for input reloads of type RELOAD_OTHER in the same
|
instructions for input reloads of type RELOAD_OTHER in the same
|
order as the reloads. Thus if the outer reload is also of type
|
order as the reloads. Thus if the outer reload is also of type
|
RELOAD_OTHER, we are guaranteed that this inner reload will be
|
RELOAD_OTHER, we are guaranteed that this inner reload will be
|
output before the outer reload. */
|
output before the outer reload. */
|
push_reload (SUBREG_REG (in), NULL_RTX, &SUBREG_REG (in), (rtx *) 0,
|
push_reload (SUBREG_REG (in), NULL_RTX, &SUBREG_REG (in), (rtx *) 0,
|
in_class, VOIDmode, VOIDmode, 0, 0, opnum, type);
|
in_class, VOIDmode, VOIDmode, 0, 0, opnum, type);
|
dont_remove_subreg = 1;
|
dont_remove_subreg = 1;
|
}
|
}
|
|
|
/* Similarly for paradoxical and problematical SUBREGs on the output.
|
/* Similarly for paradoxical and problematical SUBREGs on the output.
|
Note that there is no reason we need worry about the previous value
|
Note that there is no reason we need worry about the previous value
|
of SUBREG_REG (out); even if wider than out,
|
of SUBREG_REG (out); even if wider than out,
|
storing in a subreg is entitled to clobber it all
|
storing in a subreg is entitled to clobber it all
|
(except in the case of STRICT_LOW_PART,
|
(except in the case of STRICT_LOW_PART,
|
and in that case the constraint should label it input-output.) */
|
and in that case the constraint should label it input-output.) */
|
if (out != 0 && GET_CODE (out) == SUBREG
|
if (out != 0 && GET_CODE (out) == SUBREG
|
&& (subreg_lowpart_p (out) || strict_low)
|
&& (subreg_lowpart_p (out) || strict_low)
|
#ifdef CANNOT_CHANGE_MODE_CLASS
|
#ifdef CANNOT_CHANGE_MODE_CLASS
|
&& !CANNOT_CHANGE_MODE_CLASS (GET_MODE (SUBREG_REG (out)), outmode, class)
|
&& !CANNOT_CHANGE_MODE_CLASS (GET_MODE (SUBREG_REG (out)), outmode, class)
|
#endif
|
#endif
|
&& (CONSTANT_P (SUBREG_REG (out))
|
&& (CONSTANT_P (SUBREG_REG (out))
|
|| strict_low
|
|| strict_low
|
|| (((REG_P (SUBREG_REG (out))
|
|| (((REG_P (SUBREG_REG (out))
|
&& REGNO (SUBREG_REG (out)) >= FIRST_PSEUDO_REGISTER)
|
&& REGNO (SUBREG_REG (out)) >= FIRST_PSEUDO_REGISTER)
|
|| MEM_P (SUBREG_REG (out)))
|
|| MEM_P (SUBREG_REG (out)))
|
&& ((GET_MODE_SIZE (outmode)
|
&& ((GET_MODE_SIZE (outmode)
|
> GET_MODE_SIZE (GET_MODE (SUBREG_REG (out))))
|
> GET_MODE_SIZE (GET_MODE (SUBREG_REG (out))))
|
#ifdef WORD_REGISTER_OPERATIONS
|
#ifdef WORD_REGISTER_OPERATIONS
|
|| ((GET_MODE_SIZE (outmode)
|
|| ((GET_MODE_SIZE (outmode)
|
< GET_MODE_SIZE (GET_MODE (SUBREG_REG (out))))
|
< GET_MODE_SIZE (GET_MODE (SUBREG_REG (out))))
|
&& ((GET_MODE_SIZE (outmode) - 1) / UNITS_PER_WORD ==
|
&& ((GET_MODE_SIZE (outmode) - 1) / UNITS_PER_WORD ==
|
((GET_MODE_SIZE (GET_MODE (SUBREG_REG (out))) - 1)
|
((GET_MODE_SIZE (GET_MODE (SUBREG_REG (out))) - 1)
|
/ UNITS_PER_WORD)))
|
/ UNITS_PER_WORD)))
|
#endif
|
#endif
|
))
|
))
|
|| (REG_P (SUBREG_REG (out))
|
|| (REG_P (SUBREG_REG (out))
|
&& REGNO (SUBREG_REG (out)) < FIRST_PSEUDO_REGISTER
|
&& REGNO (SUBREG_REG (out)) < FIRST_PSEUDO_REGISTER
|
&& ((GET_MODE_SIZE (outmode) <= UNITS_PER_WORD
|
&& ((GET_MODE_SIZE (outmode) <= UNITS_PER_WORD
|
&& (GET_MODE_SIZE (GET_MODE (SUBREG_REG (out)))
|
&& (GET_MODE_SIZE (GET_MODE (SUBREG_REG (out)))
|
> UNITS_PER_WORD)
|
> UNITS_PER_WORD)
|
&& ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (out)))
|
&& ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (out)))
|
/ UNITS_PER_WORD)
|
/ UNITS_PER_WORD)
|
!= (int) hard_regno_nregs[REGNO (SUBREG_REG (out))]
|
!= (int) hard_regno_nregs[REGNO (SUBREG_REG (out))]
|
[GET_MODE (SUBREG_REG (out))]))
|
[GET_MODE (SUBREG_REG (out))]))
|
|| ! HARD_REGNO_MODE_OK (subreg_regno (out), outmode)))
|
|| ! HARD_REGNO_MODE_OK (subreg_regno (out), outmode)))
|
|| (secondary_reload_class (0, class, outmode, out) != NO_REGS
|
|| (secondary_reload_class (0, class, outmode, out) != NO_REGS
|
&& (secondary_reload_class (0, class, GET_MODE (SUBREG_REG (out)),
|
&& (secondary_reload_class (0, class, GET_MODE (SUBREG_REG (out)),
|
SUBREG_REG (out))
|
SUBREG_REG (out))
|
== NO_REGS))
|
== NO_REGS))
|
#ifdef CANNOT_CHANGE_MODE_CLASS
|
#ifdef CANNOT_CHANGE_MODE_CLASS
|
|| (REG_P (SUBREG_REG (out))
|
|| (REG_P (SUBREG_REG (out))
|
&& REGNO (SUBREG_REG (out)) < FIRST_PSEUDO_REGISTER
|
&& REGNO (SUBREG_REG (out)) < FIRST_PSEUDO_REGISTER
|
&& REG_CANNOT_CHANGE_MODE_P (REGNO (SUBREG_REG (out)),
|
&& REG_CANNOT_CHANGE_MODE_P (REGNO (SUBREG_REG (out)),
|
GET_MODE (SUBREG_REG (out)),
|
GET_MODE (SUBREG_REG (out)),
|
outmode))
|
outmode))
|
#endif
|
#endif
|
))
|
))
|
{
|
{
|
out_subreg_loc = outloc;
|
out_subreg_loc = outloc;
|
outloc = &SUBREG_REG (out);
|
outloc = &SUBREG_REG (out);
|
out = *outloc;
|
out = *outloc;
|
#if ! defined (LOAD_EXTEND_OP) && ! defined (WORD_REGISTER_OPERATIONS)
|
#if ! defined (LOAD_EXTEND_OP) && ! defined (WORD_REGISTER_OPERATIONS)
|
gcc_assert (!MEM_P (out)
|
gcc_assert (!MEM_P (out)
|
|| GET_MODE_SIZE (GET_MODE (out))
|
|| GET_MODE_SIZE (GET_MODE (out))
|
<= GET_MODE_SIZE (outmode));
|
<= GET_MODE_SIZE (outmode));
|
#endif
|
#endif
|
outmode = GET_MODE (out);
|
outmode = GET_MODE (out);
|
}
|
}
|
|
|
/* Similar issue for (SUBREG:M1 (REG:M2 ...) ...) for a hard register R where
|
/* Similar issue for (SUBREG:M1 (REG:M2 ...) ...) for a hard register R where
|
either M1 is not valid for R or M2 is wider than a word but we only
|
either M1 is not valid for R or M2 is wider than a word but we only
|
need one word to store an M2-sized quantity in R.
|
need one word to store an M2-sized quantity in R.
|
|
|
However, we must reload the inner reg *as well as* the subreg in
|
However, we must reload the inner reg *as well as* the subreg in
|
that case. In this case, the inner reg is an in-out reload. */
|
that case. In this case, the inner reg is an in-out reload. */
|
|
|
if (out != 0 && reload_inner_reg_of_subreg (out, outmode, 1))
|
if (out != 0 && reload_inner_reg_of_subreg (out, outmode, 1))
|
{
|
{
|
/* This relies on the fact that emit_reload_insns outputs the
|
/* This relies on the fact that emit_reload_insns outputs the
|
instructions for output reloads of type RELOAD_OTHER in reverse
|
instructions for output reloads of type RELOAD_OTHER in reverse
|
order of the reloads. Thus if the outer reload is also of type
|
order of the reloads. Thus if the outer reload is also of type
|
RELOAD_OTHER, we are guaranteed that this inner reload will be
|
RELOAD_OTHER, we are guaranteed that this inner reload will be
|
output after the outer reload. */
|
output after the outer reload. */
|
dont_remove_subreg = 1;
|
dont_remove_subreg = 1;
|
push_reload (SUBREG_REG (out), SUBREG_REG (out), &SUBREG_REG (out),
|
push_reload (SUBREG_REG (out), SUBREG_REG (out), &SUBREG_REG (out),
|
&SUBREG_REG (out),
|
&SUBREG_REG (out),
|
find_valid_class (outmode, GET_MODE (SUBREG_REG (out)),
|
find_valid_class (outmode, GET_MODE (SUBREG_REG (out)),
|
subreg_regno_offset (REGNO (SUBREG_REG (out)),
|
subreg_regno_offset (REGNO (SUBREG_REG (out)),
|
GET_MODE (SUBREG_REG (out)),
|
GET_MODE (SUBREG_REG (out)),
|
SUBREG_BYTE (out),
|
SUBREG_BYTE (out),
|
GET_MODE (out)),
|
GET_MODE (out)),
|
REGNO (SUBREG_REG (out))),
|
REGNO (SUBREG_REG (out))),
|
VOIDmode, VOIDmode, 0, 0,
|
VOIDmode, VOIDmode, 0, 0,
|
opnum, RELOAD_OTHER);
|
opnum, RELOAD_OTHER);
|
}
|
}
|
|
|
/* If IN appears in OUT, we can't share any input-only reload for IN. */
|
/* If IN appears in OUT, we can't share any input-only reload for IN. */
|
if (in != 0 && out != 0 && MEM_P (out)
|
if (in != 0 && out != 0 && MEM_P (out)
|
&& (REG_P (in) || MEM_P (in) || GET_CODE (in) == PLUS)
|
&& (REG_P (in) || MEM_P (in) || GET_CODE (in) == PLUS)
|
&& reg_overlap_mentioned_for_reload_p (in, XEXP (out, 0)))
|
&& reg_overlap_mentioned_for_reload_p (in, XEXP (out, 0)))
|
dont_share = 1;
|
dont_share = 1;
|
|
|
/* If IN is a SUBREG of a hard register, make a new REG. This
|
/* If IN is a SUBREG of a hard register, make a new REG. This
|
simplifies some of the cases below. */
|
simplifies some of the cases below. */
|
|
|
if (in != 0 && GET_CODE (in) == SUBREG && REG_P (SUBREG_REG (in))
|
if (in != 0 && GET_CODE (in) == SUBREG && REG_P (SUBREG_REG (in))
|
&& REGNO (SUBREG_REG (in)) < FIRST_PSEUDO_REGISTER
|
&& REGNO (SUBREG_REG (in)) < FIRST_PSEUDO_REGISTER
|
&& ! dont_remove_subreg)
|
&& ! dont_remove_subreg)
|
in = gen_rtx_REG (GET_MODE (in), subreg_regno (in));
|
in = gen_rtx_REG (GET_MODE (in), subreg_regno (in));
|
|
|
/* Similarly for OUT. */
|
/* Similarly for OUT. */
|
if (out != 0 && GET_CODE (out) == SUBREG
|
if (out != 0 && GET_CODE (out) == SUBREG
|
&& REG_P (SUBREG_REG (out))
|
&& REG_P (SUBREG_REG (out))
|
&& REGNO (SUBREG_REG (out)) < FIRST_PSEUDO_REGISTER
|
&& REGNO (SUBREG_REG (out)) < FIRST_PSEUDO_REGISTER
|
&& ! dont_remove_subreg)
|
&& ! dont_remove_subreg)
|
out = gen_rtx_REG (GET_MODE (out), subreg_regno (out));
|
out = gen_rtx_REG (GET_MODE (out), subreg_regno (out));
|
|
|
/* Narrow down the class of register wanted if that is
|
/* Narrow down the class of register wanted if that is
|
desirable on this machine for efficiency. */
|
desirable on this machine for efficiency. */
|
{
|
{
|
enum reg_class preferred_class = class;
|
enum reg_class preferred_class = class;
|
|
|
if (in != 0)
|
if (in != 0)
|
preferred_class = PREFERRED_RELOAD_CLASS (in, class);
|
preferred_class = PREFERRED_RELOAD_CLASS (in, class);
|
|
|
/* Output reloads may need analogous treatment, different in detail. */
|
/* Output reloads may need analogous treatment, different in detail. */
|
#ifdef PREFERRED_OUTPUT_RELOAD_CLASS
|
#ifdef PREFERRED_OUTPUT_RELOAD_CLASS
|
if (out != 0)
|
if (out != 0)
|
preferred_class = PREFERRED_OUTPUT_RELOAD_CLASS (out, preferred_class);
|
preferred_class = PREFERRED_OUTPUT_RELOAD_CLASS (out, preferred_class);
|
#endif
|
#endif
|
|
|
/* Discard what the target said if we cannot do it. */
|
/* Discard what the target said if we cannot do it. */
|
if (preferred_class != NO_REGS
|
if (preferred_class != NO_REGS
|
|| (optional && type == RELOAD_FOR_OUTPUT))
|
|| (optional && type == RELOAD_FOR_OUTPUT))
|
class = preferred_class;
|
class = preferred_class;
|
}
|
}
|
|
|
/* Make sure we use a class that can handle the actual pseudo
|
/* Make sure we use a class that can handle the actual pseudo
|
inside any subreg. For example, on the 386, QImode regs
|
inside any subreg. For example, on the 386, QImode regs
|
can appear within SImode subregs. Although GENERAL_REGS
|
can appear within SImode subregs. Although GENERAL_REGS
|
can handle SImode, QImode needs a smaller class. */
|
can handle SImode, QImode needs a smaller class. */
|
#ifdef LIMIT_RELOAD_CLASS
|
#ifdef LIMIT_RELOAD_CLASS
|
if (in_subreg_loc)
|
if (in_subreg_loc)
|
class = LIMIT_RELOAD_CLASS (inmode, class);
|
class = LIMIT_RELOAD_CLASS (inmode, class);
|
else if (in != 0 && GET_CODE (in) == SUBREG)
|
else if (in != 0 && GET_CODE (in) == SUBREG)
|
class = LIMIT_RELOAD_CLASS (GET_MODE (SUBREG_REG (in)), class);
|
class = LIMIT_RELOAD_CLASS (GET_MODE (SUBREG_REG (in)), class);
|
|
|
if (out_subreg_loc)
|
if (out_subreg_loc)
|
class = LIMIT_RELOAD_CLASS (outmode, class);
|
class = LIMIT_RELOAD_CLASS (outmode, class);
|
if (out != 0 && GET_CODE (out) == SUBREG)
|
if (out != 0 && GET_CODE (out) == SUBREG)
|
class = LIMIT_RELOAD_CLASS (GET_MODE (SUBREG_REG (out)), class);
|
class = LIMIT_RELOAD_CLASS (GET_MODE (SUBREG_REG (out)), class);
|
#endif
|
#endif
|
|
|
/* Verify that this class is at least possible for the mode that
|
/* Verify that this class is at least possible for the mode that
|
is specified. */
|
is specified. */
|
if (this_insn_is_asm)
|
if (this_insn_is_asm)
|
{
|
{
|
enum machine_mode mode;
|
enum machine_mode mode;
|
if (GET_MODE_SIZE (inmode) > GET_MODE_SIZE (outmode))
|
if (GET_MODE_SIZE (inmode) > GET_MODE_SIZE (outmode))
|
mode = inmode;
|
mode = inmode;
|
else
|
else
|
mode = outmode;
|
mode = outmode;
|
if (mode == VOIDmode)
|
if (mode == VOIDmode)
|
{
|
{
|
error_for_asm (this_insn, "cannot reload integer constant "
|
error_for_asm (this_insn, "cannot reload integer constant "
|
"operand in %<asm%>");
|
"operand in %<asm%>");
|
mode = word_mode;
|
mode = word_mode;
|
if (in != 0)
|
if (in != 0)
|
inmode = word_mode;
|
inmode = word_mode;
|
if (out != 0)
|
if (out != 0)
|
outmode = word_mode;
|
outmode = word_mode;
|
}
|
}
|
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
|
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
|
if (HARD_REGNO_MODE_OK (i, mode)
|
if (HARD_REGNO_MODE_OK (i, mode)
|
&& TEST_HARD_REG_BIT (reg_class_contents[(int) class], i))
|
&& TEST_HARD_REG_BIT (reg_class_contents[(int) class], i))
|
{
|
{
|
int nregs = hard_regno_nregs[i][mode];
|
int nregs = hard_regno_nregs[i][mode];
|
|
|
int j;
|
int j;
|
for (j = 1; j < nregs; j++)
|
for (j = 1; j < nregs; j++)
|
if (! TEST_HARD_REG_BIT (reg_class_contents[(int) class], i + j))
|
if (! TEST_HARD_REG_BIT (reg_class_contents[(int) class], i + j))
|
break;
|
break;
|
if (j == nregs)
|
if (j == nregs)
|
break;
|
break;
|
}
|
}
|
if (i == FIRST_PSEUDO_REGISTER)
|
if (i == FIRST_PSEUDO_REGISTER)
|
{
|
{
|
error_for_asm (this_insn, "impossible register constraint "
|
error_for_asm (this_insn, "impossible register constraint "
|
"in %<asm%>");
|
"in %<asm%>");
|
/* Avoid further trouble with this insn. */
|
/* Avoid further trouble with this insn. */
|
PATTERN (this_insn) = gen_rtx_USE (VOIDmode, const0_rtx);
|
PATTERN (this_insn) = gen_rtx_USE (VOIDmode, const0_rtx);
|
/* We used to continue here setting class to ALL_REGS, but it triggers
|
/* We used to continue here setting class to ALL_REGS, but it triggers
|
sanity check on i386 for:
|
sanity check on i386 for:
|
void foo(long double d)
|
void foo(long double d)
|
{
|
{
|
asm("" :: "a" (d));
|
asm("" :: "a" (d));
|
}
|
}
|
Returning zero here ought to be safe as we take care in
|
Returning zero here ought to be safe as we take care in
|
find_reloads to not process the reloads when instruction was
|
find_reloads to not process the reloads when instruction was
|
replaced by USE. */
|
replaced by USE. */
|
|
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
|
|
/* Optional output reloads are always OK even if we have no register class,
|
/* Optional output reloads are always OK even if we have no register class,
|
since the function of these reloads is only to have spill_reg_store etc.
|
since the function of these reloads is only to have spill_reg_store etc.
|
set, so that the storing insn can be deleted later. */
|
set, so that the storing insn can be deleted later. */
|
gcc_assert (class != NO_REGS
|
gcc_assert (class != NO_REGS
|
|| (optional != 0 && type == RELOAD_FOR_OUTPUT));
|
|| (optional != 0 && type == RELOAD_FOR_OUTPUT));
|
|
|
i = find_reusable_reload (&in, out, class, type, opnum, dont_share);
|
i = find_reusable_reload (&in, out, class, type, opnum, dont_share);
|
|
|
if (i == n_reloads)
|
if (i == n_reloads)
|
{
|
{
|
/* See if we need a secondary reload register to move between CLASS
|
/* See if we need a secondary reload register to move between CLASS
|
and IN or CLASS and OUT. Get the icode and push any required reloads
|
and IN or CLASS and OUT. Get the icode and push any required reloads
|
needed for each of them if so. */
|
needed for each of them if so. */
|
|
|
if (in != 0)
|
if (in != 0)
|
secondary_in_reload
|
secondary_in_reload
|
= push_secondary_reload (1, in, opnum, optional, class, inmode, type,
|
= push_secondary_reload (1, in, opnum, optional, class, inmode, type,
|
&secondary_in_icode, NULL);
|
&secondary_in_icode, NULL);
|
if (out != 0 && GET_CODE (out) != SCRATCH)
|
if (out != 0 && GET_CODE (out) != SCRATCH)
|
secondary_out_reload
|
secondary_out_reload
|
= push_secondary_reload (0, out, opnum, optional, class, outmode,
|
= push_secondary_reload (0, out, opnum, optional, class, outmode,
|
type, &secondary_out_icode, NULL);
|
type, &secondary_out_icode, NULL);
|
|
|
/* We found no existing reload suitable for re-use.
|
/* We found no existing reload suitable for re-use.
|
So add an additional reload. */
|
So add an additional reload. */
|
|
|
#ifdef SECONDARY_MEMORY_NEEDED
|
#ifdef SECONDARY_MEMORY_NEEDED
|
/* If a memory location is needed for the copy, make one. */
|
/* If a memory location is needed for the copy, make one. */
|
if (in != 0
|
if (in != 0
|
&& (REG_P (in)
|
&& (REG_P (in)
|
|| (GET_CODE (in) == SUBREG && REG_P (SUBREG_REG (in))))
|
|| (GET_CODE (in) == SUBREG && REG_P (SUBREG_REG (in))))
|
&& reg_or_subregno (in) < FIRST_PSEUDO_REGISTER
|
&& reg_or_subregno (in) < FIRST_PSEUDO_REGISTER
|
&& SECONDARY_MEMORY_NEEDED (REGNO_REG_CLASS (reg_or_subregno (in)),
|
&& SECONDARY_MEMORY_NEEDED (REGNO_REG_CLASS (reg_or_subregno (in)),
|
class, inmode))
|
class, inmode))
|
get_secondary_mem (in, inmode, opnum, type);
|
get_secondary_mem (in, inmode, opnum, type);
|
#endif
|
#endif
|
|
|
i = n_reloads;
|
i = n_reloads;
|
rld[i].in = in;
|
rld[i].in = in;
|
rld[i].out = out;
|
rld[i].out = out;
|
rld[i].class = class;
|
rld[i].class = class;
|
rld[i].inmode = inmode;
|
rld[i].inmode = inmode;
|
rld[i].outmode = outmode;
|
rld[i].outmode = outmode;
|
rld[i].reg_rtx = 0;
|
rld[i].reg_rtx = 0;
|
rld[i].optional = optional;
|
rld[i].optional = optional;
|
rld[i].inc = 0;
|
rld[i].inc = 0;
|
rld[i].nocombine = 0;
|
rld[i].nocombine = 0;
|
rld[i].in_reg = inloc ? *inloc : 0;
|
rld[i].in_reg = inloc ? *inloc : 0;
|
rld[i].out_reg = outloc ? *outloc : 0;
|
rld[i].out_reg = outloc ? *outloc : 0;
|
rld[i].opnum = opnum;
|
rld[i].opnum = opnum;
|
rld[i].when_needed = type;
|
rld[i].when_needed = type;
|
rld[i].secondary_in_reload = secondary_in_reload;
|
rld[i].secondary_in_reload = secondary_in_reload;
|
rld[i].secondary_out_reload = secondary_out_reload;
|
rld[i].secondary_out_reload = secondary_out_reload;
|
rld[i].secondary_in_icode = secondary_in_icode;
|
rld[i].secondary_in_icode = secondary_in_icode;
|
rld[i].secondary_out_icode = secondary_out_icode;
|
rld[i].secondary_out_icode = secondary_out_icode;
|
rld[i].secondary_p = 0;
|
rld[i].secondary_p = 0;
|
|
|
n_reloads++;
|
n_reloads++;
|
|
|
#ifdef SECONDARY_MEMORY_NEEDED
|
#ifdef SECONDARY_MEMORY_NEEDED
|
if (out != 0
|
if (out != 0
|
&& (REG_P (out)
|
&& (REG_P (out)
|
|| (GET_CODE (out) == SUBREG && REG_P (SUBREG_REG (out))))
|
|| (GET_CODE (out) == SUBREG && REG_P (SUBREG_REG (out))))
|
&& reg_or_subregno (out) < FIRST_PSEUDO_REGISTER
|
&& reg_or_subregno (out) < FIRST_PSEUDO_REGISTER
|
&& SECONDARY_MEMORY_NEEDED (class,
|
&& SECONDARY_MEMORY_NEEDED (class,
|
REGNO_REG_CLASS (reg_or_subregno (out)),
|
REGNO_REG_CLASS (reg_or_subregno (out)),
|
outmode))
|
outmode))
|
get_secondary_mem (out, outmode, opnum, type);
|
get_secondary_mem (out, outmode, opnum, type);
|
#endif
|
#endif
|
}
|
}
|
else
|
else
|
{
|
{
|
/* We are reusing an existing reload,
|
/* We are reusing an existing reload,
|
but we may have additional information for it.
|
but we may have additional information for it.
|
For example, we may now have both IN and OUT
|
For example, we may now have both IN and OUT
|
while the old one may have just one of them. */
|
while the old one may have just one of them. */
|
|
|
/* The modes can be different. If they are, we want to reload in
|
/* The modes can be different. If they are, we want to reload in
|
the larger mode, so that the value is valid for both modes. */
|
the larger mode, so that the value is valid for both modes. */
|
if (inmode != VOIDmode
|
if (inmode != VOIDmode
|
&& GET_MODE_SIZE (inmode) > GET_MODE_SIZE (rld[i].inmode))
|
&& GET_MODE_SIZE (inmode) > GET_MODE_SIZE (rld[i].inmode))
|
rld[i].inmode = inmode;
|
rld[i].inmode = inmode;
|
if (outmode != VOIDmode
|
if (outmode != VOIDmode
|
&& GET_MODE_SIZE (outmode) > GET_MODE_SIZE (rld[i].outmode))
|
&& GET_MODE_SIZE (outmode) > GET_MODE_SIZE (rld[i].outmode))
|
rld[i].outmode = outmode;
|
rld[i].outmode = outmode;
|
if (in != 0)
|
if (in != 0)
|
{
|
{
|
rtx in_reg = inloc ? *inloc : 0;
|
rtx in_reg = inloc ? *inloc : 0;
|
/* If we merge reloads for two distinct rtl expressions that
|
/* If we merge reloads for two distinct rtl expressions that
|
are identical in content, there might be duplicate address
|
are identical in content, there might be duplicate address
|
reloads. Remove the extra set now, so that if we later find
|
reloads. Remove the extra set now, so that if we later find
|
that we can inherit this reload, we can get rid of the
|
that we can inherit this reload, we can get rid of the
|
address reloads altogether.
|
address reloads altogether.
|
|
|
Do not do this if both reloads are optional since the result
|
Do not do this if both reloads are optional since the result
|
would be an optional reload which could potentially leave
|
would be an optional reload which could potentially leave
|
unresolved address replacements.
|
unresolved address replacements.
|
|
|
It is not sufficient to call transfer_replacements since
|
It is not sufficient to call transfer_replacements since
|
choose_reload_regs will remove the replacements for address
|
choose_reload_regs will remove the replacements for address
|
reloads of inherited reloads which results in the same
|
reloads of inherited reloads which results in the same
|
problem. */
|
problem. */
|
if (rld[i].in != in && rtx_equal_p (in, rld[i].in)
|
if (rld[i].in != in && rtx_equal_p (in, rld[i].in)
|
&& ! (rld[i].optional && optional))
|
&& ! (rld[i].optional && optional))
|
{
|
{
|
/* We must keep the address reload with the lower operand
|
/* We must keep the address reload with the lower operand
|
number alive. */
|
number alive. */
|
if (opnum > rld[i].opnum)
|
if (opnum > rld[i].opnum)
|
{
|
{
|
remove_address_replacements (in);
|
remove_address_replacements (in);
|
in = rld[i].in;
|
in = rld[i].in;
|
in_reg = rld[i].in_reg;
|
in_reg = rld[i].in_reg;
|
}
|
}
|
else
|
else
|
remove_address_replacements (rld[i].in);
|
remove_address_replacements (rld[i].in);
|
}
|
}
|
rld[i].in = in;
|
rld[i].in = in;
|
rld[i].in_reg = in_reg;
|
rld[i].in_reg = in_reg;
|
}
|
}
|
if (out != 0)
|
if (out != 0)
|
{
|
{
|
rld[i].out = out;
|
rld[i].out = out;
|
rld[i].out_reg = outloc ? *outloc : 0;
|
rld[i].out_reg = outloc ? *outloc : 0;
|
}
|
}
|
if (reg_class_subset_p (class, rld[i].class))
|
if (reg_class_subset_p (class, rld[i].class))
|
rld[i].class = class;
|
rld[i].class = class;
|
rld[i].optional &= optional;
|
rld[i].optional &= optional;
|
if (MERGE_TO_OTHER (type, rld[i].when_needed,
|
if (MERGE_TO_OTHER (type, rld[i].when_needed,
|
opnum, rld[i].opnum))
|
opnum, rld[i].opnum))
|
rld[i].when_needed = RELOAD_OTHER;
|
rld[i].when_needed = RELOAD_OTHER;
|
rld[i].opnum = MIN (rld[i].opnum, opnum);
|
rld[i].opnum = MIN (rld[i].opnum, opnum);
|
}
|
}
|
|
|
/* If the ostensible rtx being reloaded differs from the rtx found
|
/* If the ostensible rtx being reloaded differs from the rtx found
|
in the location to substitute, this reload is not safe to combine
|
in the location to substitute, this reload is not safe to combine
|
because we cannot reliably tell whether it appears in the insn. */
|
because we cannot reliably tell whether it appears in the insn. */
|
|
|
if (in != 0 && in != *inloc)
|
if (in != 0 && in != *inloc)
|
rld[i].nocombine = 1;
|
rld[i].nocombine = 1;
|
|
|
#if 0
|
#if 0
|
/* This was replaced by changes in find_reloads_address_1 and the new
|
/* This was replaced by changes in find_reloads_address_1 and the new
|
function inc_for_reload, which go with a new meaning of reload_inc. */
|
function inc_for_reload, which go with a new meaning of reload_inc. */
|
|
|
/* If this is an IN/OUT reload in an insn that sets the CC,
|
/* If this is an IN/OUT reload in an insn that sets the CC,
|
it must be for an autoincrement. It doesn't work to store
|
it must be for an autoincrement. It doesn't work to store
|
the incremented value after the insn because that would clobber the CC.
|
the incremented value after the insn because that would clobber the CC.
|
So we must do the increment of the value reloaded from,
|
So we must do the increment of the value reloaded from,
|
increment it, store it back, then decrement again. */
|
increment it, store it back, then decrement again. */
|
if (out != 0 && sets_cc0_p (PATTERN (this_insn)))
|
if (out != 0 && sets_cc0_p (PATTERN (this_insn)))
|
{
|
{
|
out = 0;
|
out = 0;
|
rld[i].out = 0;
|
rld[i].out = 0;
|
rld[i].inc = find_inc_amount (PATTERN (this_insn), in);
|
rld[i].inc = find_inc_amount (PATTERN (this_insn), in);
|
/* If we did not find a nonzero amount-to-increment-by,
|
/* If we did not find a nonzero amount-to-increment-by,
|
that contradicts the belief that IN is being incremented
|
that contradicts the belief that IN is being incremented
|
in an address in this insn. */
|
in an address in this insn. */
|
gcc_assert (rld[i].inc != 0);
|
gcc_assert (rld[i].inc != 0);
|
}
|
}
|
#endif
|
#endif
|
|
|
/* If we will replace IN and OUT with the reload-reg,
|
/* If we will replace IN and OUT with the reload-reg,
|
record where they are located so that substitution need
|
record where they are located so that substitution need
|
not do a tree walk. */
|
not do a tree walk. */
|
|
|
if (replace_reloads)
|
if (replace_reloads)
|
{
|
{
|
if (inloc != 0)
|
if (inloc != 0)
|
{
|
{
|
struct replacement *r = &replacements[n_replacements++];
|
struct replacement *r = &replacements[n_replacements++];
|
r->what = i;
|
r->what = i;
|
r->subreg_loc = in_subreg_loc;
|
r->subreg_loc = in_subreg_loc;
|
r->where = inloc;
|
r->where = inloc;
|
r->mode = inmode;
|
r->mode = inmode;
|
}
|
}
|
if (outloc != 0 && outloc != inloc)
|
if (outloc != 0 && outloc != inloc)
|
{
|
{
|
struct replacement *r = &replacements[n_replacements++];
|
struct replacement *r = &replacements[n_replacements++];
|
r->what = i;
|
r->what = i;
|
r->where = outloc;
|
r->where = outloc;
|
r->subreg_loc = out_subreg_loc;
|
r->subreg_loc = out_subreg_loc;
|
r->mode = outmode;
|
r->mode = outmode;
|
}
|
}
|
}
|
}
|
|
|
/* If this reload is just being introduced and it has both
|
/* If this reload is just being introduced and it has both
|
an incoming quantity and an outgoing quantity that are
|
an incoming quantity and an outgoing quantity that are
|
supposed to be made to match, see if either one of the two
|
supposed to be made to match, see if either one of the two
|
can serve as the place to reload into.
|
can serve as the place to reload into.
|
|
|
If one of them is acceptable, set rld[i].reg_rtx
|
If one of them is acceptable, set rld[i].reg_rtx
|
to that one. */
|
to that one. */
|
|
|
if (in != 0 && out != 0 && in != out && rld[i].reg_rtx == 0)
|
if (in != 0 && out != 0 && in != out && rld[i].reg_rtx == 0)
|
{
|
{
|
rld[i].reg_rtx = find_dummy_reload (in, out, inloc, outloc,
|
rld[i].reg_rtx = find_dummy_reload (in, out, inloc, outloc,
|
inmode, outmode,
|
inmode, outmode,
|
rld[i].class, i,
|
rld[i].class, i,
|
earlyclobber_operand_p (out));
|
earlyclobber_operand_p (out));
|
|
|
/* If the outgoing register already contains the same value
|
/* If the outgoing register already contains the same value
|
as the incoming one, we can dispense with loading it.
|
as the incoming one, we can dispense with loading it.
|
The easiest way to tell the caller that is to give a phony
|
The easiest way to tell the caller that is to give a phony
|
value for the incoming operand (same as outgoing one). */
|
value for the incoming operand (same as outgoing one). */
|
if (rld[i].reg_rtx == out
|
if (rld[i].reg_rtx == out
|
&& (REG_P (in) || CONSTANT_P (in))
|
&& (REG_P (in) || CONSTANT_P (in))
|
&& 0 != find_equiv_reg (in, this_insn, 0, REGNO (out),
|
&& 0 != find_equiv_reg (in, this_insn, 0, REGNO (out),
|
static_reload_reg_p, i, inmode))
|
static_reload_reg_p, i, inmode))
|
rld[i].in = out;
|
rld[i].in = out;
|
}
|
}
|
|
|
/* If this is an input reload and the operand contains a register that
|
/* If this is an input reload and the operand contains a register that
|
dies in this insn and is used nowhere else, see if it is the right class
|
dies in this insn and is used nowhere else, see if it is the right class
|
to be used for this reload. Use it if so. (This occurs most commonly
|
to be used for this reload. Use it if so. (This occurs most commonly
|
in the case of paradoxical SUBREGs and in-out reloads). We cannot do
|
in the case of paradoxical SUBREGs and in-out reloads). We cannot do
|
this if it is also an output reload that mentions the register unless
|
this if it is also an output reload that mentions the register unless
|
the output is a SUBREG that clobbers an entire register.
|
the output is a SUBREG that clobbers an entire register.
|
|
|
Note that the operand might be one of the spill regs, if it is a
|
Note that the operand might be one of the spill regs, if it is a
|
pseudo reg and we are in a block where spilling has not taken place.
|
pseudo reg and we are in a block where spilling has not taken place.
|
But if there is no spilling in this block, that is OK.
|
But if there is no spilling in this block, that is OK.
|
An explicitly used hard reg cannot be a spill reg. */
|
An explicitly used hard reg cannot be a spill reg. */
|
|
|
if (rld[i].reg_rtx == 0 && in != 0 && hard_regs_live_known)
|
if (rld[i].reg_rtx == 0 && in != 0 && hard_regs_live_known)
|
{
|
{
|
rtx note;
|
rtx note;
|
int regno;
|
int regno;
|
enum machine_mode rel_mode = inmode;
|
enum machine_mode rel_mode = inmode;
|
|
|
if (out && GET_MODE_SIZE (outmode) > GET_MODE_SIZE (inmode))
|
if (out && GET_MODE_SIZE (outmode) > GET_MODE_SIZE (inmode))
|
rel_mode = outmode;
|
rel_mode = outmode;
|
|
|
for (note = REG_NOTES (this_insn); note; note = XEXP (note, 1))
|
for (note = REG_NOTES (this_insn); note; note = XEXP (note, 1))
|
if (REG_NOTE_KIND (note) == REG_DEAD
|
if (REG_NOTE_KIND (note) == REG_DEAD
|
&& REG_P (XEXP (note, 0))
|
&& REG_P (XEXP (note, 0))
|
&& (regno = REGNO (XEXP (note, 0))) < FIRST_PSEUDO_REGISTER
|
&& (regno = REGNO (XEXP (note, 0))) < FIRST_PSEUDO_REGISTER
|
&& reg_mentioned_p (XEXP (note, 0), in)
|
&& reg_mentioned_p (XEXP (note, 0), in)
|
/* Check that we don't use a hardreg for an uninitialized
|
/* Check that we don't use a hardreg for an uninitialized
|
pseudo. See also find_dummy_reload(). */
|
pseudo. See also find_dummy_reload(). */
|
&& (ORIGINAL_REGNO (XEXP (note, 0)) < FIRST_PSEUDO_REGISTER
|
&& (ORIGINAL_REGNO (XEXP (note, 0)) < FIRST_PSEUDO_REGISTER
|
|| ! bitmap_bit_p (ENTRY_BLOCK_PTR->il.rtl->global_live_at_end,
|
|| ! bitmap_bit_p (ENTRY_BLOCK_PTR->il.rtl->global_live_at_end,
|
ORIGINAL_REGNO (XEXP (note, 0))))
|
ORIGINAL_REGNO (XEXP (note, 0))))
|
&& ! refers_to_regno_for_reload_p (regno,
|
&& ! refers_to_regno_for_reload_p (regno,
|
(regno
|
(regno
|
+ hard_regno_nregs[regno]
|
+ hard_regno_nregs[regno]
|
[rel_mode]),
|
[rel_mode]),
|
PATTERN (this_insn), inloc)
|
PATTERN (this_insn), inloc)
|
/* If this is also an output reload, IN cannot be used as
|
/* If this is also an output reload, IN cannot be used as
|
the reload register if it is set in this insn unless IN
|
the reload register if it is set in this insn unless IN
|
is also OUT. */
|
is also OUT. */
|
&& (out == 0 || in == out
|
&& (out == 0 || in == out
|
|| ! hard_reg_set_here_p (regno,
|
|| ! hard_reg_set_here_p (regno,
|
(regno
|
(regno
|
+ hard_regno_nregs[regno]
|
+ hard_regno_nregs[regno]
|
[rel_mode]),
|
[rel_mode]),
|
PATTERN (this_insn)))
|
PATTERN (this_insn)))
|
/* ??? Why is this code so different from the previous?
|
/* ??? Why is this code so different from the previous?
|
Is there any simple coherent way to describe the two together?
|
Is there any simple coherent way to describe the two together?
|
What's going on here. */
|
What's going on here. */
|
&& (in != out
|
&& (in != out
|
|| (GET_CODE (in) == SUBREG
|
|| (GET_CODE (in) == SUBREG
|
&& (((GET_MODE_SIZE (GET_MODE (in)) + (UNITS_PER_WORD - 1))
|
&& (((GET_MODE_SIZE (GET_MODE (in)) + (UNITS_PER_WORD - 1))
|
/ UNITS_PER_WORD)
|
/ UNITS_PER_WORD)
|
== ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (in)))
|
== ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (in)))
|
+ (UNITS_PER_WORD - 1)) / UNITS_PER_WORD))))
|
+ (UNITS_PER_WORD - 1)) / UNITS_PER_WORD))))
|
/* Make sure the operand fits in the reg that dies. */
|
/* Make sure the operand fits in the reg that dies. */
|
&& (GET_MODE_SIZE (rel_mode)
|
&& (GET_MODE_SIZE (rel_mode)
|
<= GET_MODE_SIZE (GET_MODE (XEXP (note, 0))))
|
<= GET_MODE_SIZE (GET_MODE (XEXP (note, 0))))
|
&& HARD_REGNO_MODE_OK (regno, inmode)
|
&& HARD_REGNO_MODE_OK (regno, inmode)
|
&& HARD_REGNO_MODE_OK (regno, outmode))
|
&& HARD_REGNO_MODE_OK (regno, outmode))
|
{
|
{
|
unsigned int offs;
|
unsigned int offs;
|
unsigned int nregs = MAX (hard_regno_nregs[regno][inmode],
|
unsigned int nregs = MAX (hard_regno_nregs[regno][inmode],
|
hard_regno_nregs[regno][outmode]);
|
hard_regno_nregs[regno][outmode]);
|
|
|
for (offs = 0; offs < nregs; offs++)
|
for (offs = 0; offs < nregs; offs++)
|
if (fixed_regs[regno + offs]
|
if (fixed_regs[regno + offs]
|
|| ! TEST_HARD_REG_BIT (reg_class_contents[(int) class],
|
|| ! TEST_HARD_REG_BIT (reg_class_contents[(int) class],
|
regno + offs))
|
regno + offs))
|
break;
|
break;
|
|
|
if (offs == nregs
|
if (offs == nregs
|
&& (! (refers_to_regno_for_reload_p
|
&& (! (refers_to_regno_for_reload_p
|
(regno, (regno + hard_regno_nregs[regno][inmode]),
|
(regno, (regno + hard_regno_nregs[regno][inmode]),
|
in, (rtx *)0))
|
in, (rtx *)0))
|
|| can_reload_into (in, regno, inmode)))
|
|| can_reload_into (in, regno, inmode)))
|
{
|
{
|
rld[i].reg_rtx = gen_rtx_REG (rel_mode, regno);
|
rld[i].reg_rtx = gen_rtx_REG (rel_mode, regno);
|
break;
|
break;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
if (out)
|
if (out)
|
output_reloadnum = i;
|
output_reloadnum = i;
|
|
|
return i;
|
return i;
|
}
|
}
|
|
|
/* Record an additional place we must replace a value
|
/* Record an additional place we must replace a value
|
for which we have already recorded a reload.
|
for which we have already recorded a reload.
|
RELOADNUM is the value returned by push_reload
|
RELOADNUM is the value returned by push_reload
|
when the reload was recorded.
|
when the reload was recorded.
|
This is used in insn patterns that use match_dup. */
|
This is used in insn patterns that use match_dup. */
|
|
|
static void
|
static void
|
push_replacement (rtx *loc, int reloadnum, enum machine_mode mode)
|
push_replacement (rtx *loc, int reloadnum, enum machine_mode mode)
|
{
|
{
|
if (replace_reloads)
|
if (replace_reloads)
|
{
|
{
|
struct replacement *r = &replacements[n_replacements++];
|
struct replacement *r = &replacements[n_replacements++];
|
r->what = reloadnum;
|
r->what = reloadnum;
|
r->where = loc;
|
r->where = loc;
|
r->subreg_loc = 0;
|
r->subreg_loc = 0;
|
r->mode = mode;
|
r->mode = mode;
|
}
|
}
|
}
|
}
|
|
|
/* Duplicate any replacement we have recorded to apply at
|
/* Duplicate any replacement we have recorded to apply at
|
location ORIG_LOC to also be performed at DUP_LOC.
|
location ORIG_LOC to also be performed at DUP_LOC.
|
This is used in insn patterns that use match_dup. */
|
This is used in insn patterns that use match_dup. */
|
|
|
static void
|
static void
|
dup_replacements (rtx *dup_loc, rtx *orig_loc)
|
dup_replacements (rtx *dup_loc, rtx *orig_loc)
|
{
|
{
|
int i, n = n_replacements;
|
int i, n = n_replacements;
|
|
|
for (i = 0; i < n; i++)
|
for (i = 0; i < n; i++)
|
{
|
{
|
struct replacement *r = &replacements[i];
|
struct replacement *r = &replacements[i];
|
if (r->where == orig_loc)
|
if (r->where == orig_loc)
|
push_replacement (dup_loc, r->what, r->mode);
|
push_replacement (dup_loc, r->what, r->mode);
|
}
|
}
|
}
|
}
|
|
|
/* Transfer all replacements that used to be in reload FROM to be in
|
/* Transfer all replacements that used to be in reload FROM to be in
|
reload TO. */
|
reload TO. */
|
|
|
void
|
void
|
transfer_replacements (int to, int from)
|
transfer_replacements (int to, int from)
|
{
|
{
|
int i;
|
int i;
|
|
|
for (i = 0; i < n_replacements; i++)
|
for (i = 0; i < n_replacements; i++)
|
if (replacements[i].what == from)
|
if (replacements[i].what == from)
|
replacements[i].what = to;
|
replacements[i].what = to;
|
}
|
}
|
|
|
/* IN_RTX is the value loaded by a reload that we now decided to inherit,
|
/* IN_RTX is the value loaded by a reload that we now decided to inherit,
|
or a subpart of it. If we have any replacements registered for IN_RTX,
|
or a subpart of it. If we have any replacements registered for IN_RTX,
|
cancel the reloads that were supposed to load them.
|
cancel the reloads that were supposed to load them.
|
Return nonzero if we canceled any reloads. */
|
Return nonzero if we canceled any reloads. */
|
int
|
int
|
remove_address_replacements (rtx in_rtx)
|
remove_address_replacements (rtx in_rtx)
|
{
|
{
|
int i, j;
|
int i, j;
|
char reload_flags[MAX_RELOADS];
|
char reload_flags[MAX_RELOADS];
|
int something_changed = 0;
|
int something_changed = 0;
|
|
|
memset (reload_flags, 0, sizeof reload_flags);
|
memset (reload_flags, 0, sizeof reload_flags);
|
for (i = 0, j = 0; i < n_replacements; i++)
|
for (i = 0, j = 0; i < n_replacements; i++)
|
{
|
{
|
if (loc_mentioned_in_p (replacements[i].where, in_rtx))
|
if (loc_mentioned_in_p (replacements[i].where, in_rtx))
|
reload_flags[replacements[i].what] |= 1;
|
reload_flags[replacements[i].what] |= 1;
|
else
|
else
|
{
|
{
|
replacements[j++] = replacements[i];
|
replacements[j++] = replacements[i];
|
reload_flags[replacements[i].what] |= 2;
|
reload_flags[replacements[i].what] |= 2;
|
}
|
}
|
}
|
}
|
/* Note that the following store must be done before the recursive calls. */
|
/* Note that the following store must be done before the recursive calls. */
|
n_replacements = j;
|
n_replacements = j;
|
|
|
for (i = n_reloads - 1; i >= 0; i--)
|
for (i = n_reloads - 1; i >= 0; i--)
|
{
|
{
|
if (reload_flags[i] == 1)
|
if (reload_flags[i] == 1)
|
{
|
{
|
deallocate_reload_reg (i);
|
deallocate_reload_reg (i);
|
remove_address_replacements (rld[i].in);
|
remove_address_replacements (rld[i].in);
|
rld[i].in = 0;
|
rld[i].in = 0;
|
something_changed = 1;
|
something_changed = 1;
|
}
|
}
|
}
|
}
|
return something_changed;
|
return something_changed;
|
}
|
}
|
|
|
/* If there is only one output reload, and it is not for an earlyclobber
|
/* If there is only one output reload, and it is not for an earlyclobber
|
operand, try to combine it with a (logically unrelated) input reload
|
operand, try to combine it with a (logically unrelated) input reload
|
to reduce the number of reload registers needed.
|
to reduce the number of reload registers needed.
|
|
|
This is safe if the input reload does not appear in
|
This is safe if the input reload does not appear in
|
the value being output-reloaded, because this implies
|
the value being output-reloaded, because this implies
|
it is not needed any more once the original insn completes.
|
it is not needed any more once the original insn completes.
|
|
|
If that doesn't work, see we can use any of the registers that
|
If that doesn't work, see we can use any of the registers that
|
die in this insn as a reload register. We can if it is of the right
|
die in this insn as a reload register. We can if it is of the right
|
class and does not appear in the value being output-reloaded. */
|
class and does not appear in the value being output-reloaded. */
|
|
|
static void
|
static void
|
combine_reloads (void)
|
combine_reloads (void)
|
{
|
{
|
int i;
|
int i;
|
int output_reload = -1;
|
int output_reload = -1;
|
int secondary_out = -1;
|
int secondary_out = -1;
|
rtx note;
|
rtx note;
|
|
|
/* Find the output reload; return unless there is exactly one
|
/* Find the output reload; return unless there is exactly one
|
and that one is mandatory. */
|
and that one is mandatory. */
|
|
|
for (i = 0; i < n_reloads; i++)
|
for (i = 0; i < n_reloads; i++)
|
if (rld[i].out != 0)
|
if (rld[i].out != 0)
|
{
|
{
|
if (output_reload >= 0)
|
if (output_reload >= 0)
|
return;
|
return;
|
output_reload = i;
|
output_reload = i;
|
}
|
}
|
|
|
if (output_reload < 0 || rld[output_reload].optional)
|
if (output_reload < 0 || rld[output_reload].optional)
|
return;
|
return;
|
|
|
/* An input-output reload isn't combinable. */
|
/* An input-output reload isn't combinable. */
|
|
|
if (rld[output_reload].in != 0)
|
if (rld[output_reload].in != 0)
|
return;
|
return;
|
|
|
/* If this reload is for an earlyclobber operand, we can't do anything. */
|
/* If this reload is for an earlyclobber operand, we can't do anything. */
|
if (earlyclobber_operand_p (rld[output_reload].out))
|
if (earlyclobber_operand_p (rld[output_reload].out))
|
return;
|
return;
|
|
|
/* If there is a reload for part of the address of this operand, we would
|
/* If there is a reload for part of the address of this operand, we would
|
need to chnage it to RELOAD_FOR_OTHER_ADDRESS. But that would extend
|
need to chnage it to RELOAD_FOR_OTHER_ADDRESS. But that would extend
|
its life to the point where doing this combine would not lower the
|
its life to the point where doing this combine would not lower the
|
number of spill registers needed. */
|
number of spill registers needed. */
|
for (i = 0; i < n_reloads; i++)
|
for (i = 0; i < n_reloads; i++)
|
if ((rld[i].when_needed == RELOAD_FOR_OUTPUT_ADDRESS
|
if ((rld[i].when_needed == RELOAD_FOR_OUTPUT_ADDRESS
|
|| rld[i].when_needed == RELOAD_FOR_OUTADDR_ADDRESS)
|
|| rld[i].when_needed == RELOAD_FOR_OUTADDR_ADDRESS)
|
&& rld[i].opnum == rld[output_reload].opnum)
|
&& rld[i].opnum == rld[output_reload].opnum)
|
return;
|
return;
|
|
|
/* Check each input reload; can we combine it? */
|
/* Check each input reload; can we combine it? */
|
|
|
for (i = 0; i < n_reloads; i++)
|
for (i = 0; i < n_reloads; i++)
|
if (rld[i].in && ! rld[i].optional && ! rld[i].nocombine
|
if (rld[i].in && ! rld[i].optional && ! rld[i].nocombine
|
/* Life span of this reload must not extend past main insn. */
|
/* Life span of this reload must not extend past main insn. */
|
&& rld[i].when_needed != RELOAD_FOR_OUTPUT_ADDRESS
|
&& rld[i].when_needed != RELOAD_FOR_OUTPUT_ADDRESS
|
&& rld[i].when_needed != RELOAD_FOR_OUTADDR_ADDRESS
|
&& rld[i].when_needed != RELOAD_FOR_OUTADDR_ADDRESS
|
&& rld[i].when_needed != RELOAD_OTHER
|
&& rld[i].when_needed != RELOAD_OTHER
|
&& (CLASS_MAX_NREGS (rld[i].class, rld[i].inmode)
|
&& (CLASS_MAX_NREGS (rld[i].class, rld[i].inmode)
|
== CLASS_MAX_NREGS (rld[output_reload].class,
|
== CLASS_MAX_NREGS (rld[output_reload].class,
|
rld[output_reload].outmode))
|
rld[output_reload].outmode))
|
&& rld[i].inc == 0
|
&& rld[i].inc == 0
|
&& rld[i].reg_rtx == 0
|
&& rld[i].reg_rtx == 0
|
#ifdef SECONDARY_MEMORY_NEEDED
|
#ifdef SECONDARY_MEMORY_NEEDED
|
/* Don't combine two reloads with different secondary
|
/* Don't combine two reloads with different secondary
|
memory locations. */
|
memory locations. */
|
&& (secondary_memlocs_elim[(int) rld[output_reload].outmode][rld[i].opnum] == 0
|
&& (secondary_memlocs_elim[(int) rld[output_reload].outmode][rld[i].opnum] == 0
|
|| secondary_memlocs_elim[(int) rld[output_reload].outmode][rld[output_reload].opnum] == 0
|
|| secondary_memlocs_elim[(int) rld[output_reload].outmode][rld[output_reload].opnum] == 0
|
|| rtx_equal_p (secondary_memlocs_elim[(int) rld[output_reload].outmode][rld[i].opnum],
|
|| rtx_equal_p (secondary_memlocs_elim[(int) rld[output_reload].outmode][rld[i].opnum],
|
secondary_memlocs_elim[(int) rld[output_reload].outmode][rld[output_reload].opnum]))
|
secondary_memlocs_elim[(int) rld[output_reload].outmode][rld[output_reload].opnum]))
|
#endif
|
#endif
|
&& (SMALL_REGISTER_CLASSES
|
&& (SMALL_REGISTER_CLASSES
|
? (rld[i].class == rld[output_reload].class)
|
? (rld[i].class == rld[output_reload].class)
|
: (reg_class_subset_p (rld[i].class,
|
: (reg_class_subset_p (rld[i].class,
|
rld[output_reload].class)
|
rld[output_reload].class)
|
|| reg_class_subset_p (rld[output_reload].class,
|
|| reg_class_subset_p (rld[output_reload].class,
|
rld[i].class)))
|
rld[i].class)))
|
&& (MATCHES (rld[i].in, rld[output_reload].out)
|
&& (MATCHES (rld[i].in, rld[output_reload].out)
|
/* Args reversed because the first arg seems to be
|
/* Args reversed because the first arg seems to be
|
the one that we imagine being modified
|
the one that we imagine being modified
|
while the second is the one that might be affected. */
|
while the second is the one that might be affected. */
|
|| (! reg_overlap_mentioned_for_reload_p (rld[output_reload].out,
|
|| (! reg_overlap_mentioned_for_reload_p (rld[output_reload].out,
|
rld[i].in)
|
rld[i].in)
|
/* However, if the input is a register that appears inside
|
/* However, if the input is a register that appears inside
|
the output, then we also can't share.
|
the output, then we also can't share.
|
Imagine (set (mem (reg 69)) (plus (reg 69) ...)).
|
Imagine (set (mem (reg 69)) (plus (reg 69) ...)).
|
If the same reload reg is used for both reg 69 and the
|
If the same reload reg is used for both reg 69 and the
|
result to be stored in memory, then that result
|
result to be stored in memory, then that result
|
will clobber the address of the memory ref. */
|
will clobber the address of the memory ref. */
|
&& ! (REG_P (rld[i].in)
|
&& ! (REG_P (rld[i].in)
|
&& reg_overlap_mentioned_for_reload_p (rld[i].in,
|
&& reg_overlap_mentioned_for_reload_p (rld[i].in,
|
rld[output_reload].out))))
|
rld[output_reload].out))))
|
&& ! reload_inner_reg_of_subreg (rld[i].in, rld[i].inmode,
|
&& ! reload_inner_reg_of_subreg (rld[i].in, rld[i].inmode,
|
rld[i].when_needed != RELOAD_FOR_INPUT)
|
rld[i].when_needed != RELOAD_FOR_INPUT)
|
&& (reg_class_size[(int) rld[i].class]
|
&& (reg_class_size[(int) rld[i].class]
|
|| SMALL_REGISTER_CLASSES)
|
|| SMALL_REGISTER_CLASSES)
|
/* We will allow making things slightly worse by combining an
|
/* We will allow making things slightly worse by combining an
|
input and an output, but no worse than that. */
|
input and an output, but no worse than that. */
|
&& (rld[i].when_needed == RELOAD_FOR_INPUT
|
&& (rld[i].when_needed == RELOAD_FOR_INPUT
|
|| rld[i].when_needed == RELOAD_FOR_OUTPUT))
|
|| rld[i].when_needed == RELOAD_FOR_OUTPUT))
|
{
|
{
|
int j;
|
int j;
|
|
|
/* We have found a reload to combine with! */
|
/* We have found a reload to combine with! */
|
rld[i].out = rld[output_reload].out;
|
rld[i].out = rld[output_reload].out;
|
rld[i].out_reg = rld[output_reload].out_reg;
|
rld[i].out_reg = rld[output_reload].out_reg;
|
rld[i].outmode = rld[output_reload].outmode;
|
rld[i].outmode = rld[output_reload].outmode;
|
/* Mark the old output reload as inoperative. */
|
/* Mark the old output reload as inoperative. */
|
rld[output_reload].out = 0;
|
rld[output_reload].out = 0;
|
/* The combined reload is needed for the entire insn. */
|
/* The combined reload is needed for the entire insn. */
|
rld[i].when_needed = RELOAD_OTHER;
|
rld[i].when_needed = RELOAD_OTHER;
|
/* If the output reload had a secondary reload, copy it. */
|
/* If the output reload had a secondary reload, copy it. */
|
if (rld[output_reload].secondary_out_reload != -1)
|
if (rld[output_reload].secondary_out_reload != -1)
|
{
|
{
|
rld[i].secondary_out_reload
|
rld[i].secondary_out_reload
|
= rld[output_reload].secondary_out_reload;
|
= rld[output_reload].secondary_out_reload;
|
rld[i].secondary_out_icode
|
rld[i].secondary_out_icode
|
= rld[output_reload].secondary_out_icode;
|
= rld[output_reload].secondary_out_icode;
|
}
|
}
|
|
|
#ifdef SECONDARY_MEMORY_NEEDED
|
#ifdef SECONDARY_MEMORY_NEEDED
|
/* Copy any secondary MEM. */
|
/* Copy any secondary MEM. */
|
if (secondary_memlocs_elim[(int) rld[output_reload].outmode][rld[output_reload].opnum] != 0)
|
if (secondary_memlocs_elim[(int) rld[output_reload].outmode][rld[output_reload].opnum] != 0)
|
secondary_memlocs_elim[(int) rld[output_reload].outmode][rld[i].opnum]
|
secondary_memlocs_elim[(int) rld[output_reload].outmode][rld[i].opnum]
|
= secondary_memlocs_elim[(int) rld[output_reload].outmode][rld[output_reload].opnum];
|
= secondary_memlocs_elim[(int) rld[output_reload].outmode][rld[output_reload].opnum];
|
#endif
|
#endif
|
/* If required, minimize the register class. */
|
/* If required, minimize the register class. */
|
if (reg_class_subset_p (rld[output_reload].class,
|
if (reg_class_subset_p (rld[output_reload].class,
|
rld[i].class))
|
rld[i].class))
|
rld[i].class = rld[output_reload].class;
|
rld[i].class = rld[output_reload].class;
|
|
|
/* Transfer all replacements from the old reload to the combined. */
|
/* Transfer all replacements from the old reload to the combined. */
|
for (j = 0; j < n_replacements; j++)
|
for (j = 0; j < n_replacements; j++)
|
if (replacements[j].what == output_reload)
|
if (replacements[j].what == output_reload)
|
replacements[j].what = i;
|
replacements[j].what = i;
|
|
|
return;
|
return;
|
}
|
}
|
|
|
/* If this insn has only one operand that is modified or written (assumed
|
/* If this insn has only one operand that is modified or written (assumed
|
to be the first), it must be the one corresponding to this reload. It
|
to be the first), it must be the one corresponding to this reload. It
|
is safe to use anything that dies in this insn for that output provided
|
is safe to use anything that dies in this insn for that output provided
|
that it does not occur in the output (we already know it isn't an
|
that it does not occur in the output (we already know it isn't an
|
earlyclobber. If this is an asm insn, give up. */
|
earlyclobber. If this is an asm insn, give up. */
|
|
|
if (INSN_CODE (this_insn) == -1)
|
if (INSN_CODE (this_insn) == -1)
|
return;
|
return;
|
|
|
for (i = 1; i < insn_data[INSN_CODE (this_insn)].n_operands; i++)
|
for (i = 1; i < insn_data[INSN_CODE (this_insn)].n_operands; i++)
|
if (insn_data[INSN_CODE (this_insn)].operand[i].constraint[0] == '='
|
if (insn_data[INSN_CODE (this_insn)].operand[i].constraint[0] == '='
|
|| insn_data[INSN_CODE (this_insn)].operand[i].constraint[0] == '+')
|
|| insn_data[INSN_CODE (this_insn)].operand[i].constraint[0] == '+')
|
return;
|
return;
|
|
|
/* See if some hard register that dies in this insn and is not used in
|
/* See if some hard register that dies in this insn and is not used in
|
the output is the right class. Only works if the register we pick
|
the output is the right class. Only works if the register we pick
|
up can fully hold our output reload. */
|
up can fully hold our output reload. */
|
for (note = REG_NOTES (this_insn); note; note = XEXP (note, 1))
|
for (note = REG_NOTES (this_insn); note; note = XEXP (note, 1))
|
if (REG_NOTE_KIND (note) == REG_DEAD
|
if (REG_NOTE_KIND (note) == REG_DEAD
|
&& REG_P (XEXP (note, 0))
|
&& REG_P (XEXP (note, 0))
|
&& ! reg_overlap_mentioned_for_reload_p (XEXP (note, 0),
|
&& ! reg_overlap_mentioned_for_reload_p (XEXP (note, 0),
|
rld[output_reload].out)
|
rld[output_reload].out)
|
&& REGNO (XEXP (note, 0)) < FIRST_PSEUDO_REGISTER
|
&& REGNO (XEXP (note, 0)) < FIRST_PSEUDO_REGISTER
|
&& HARD_REGNO_MODE_OK (REGNO (XEXP (note, 0)), rld[output_reload].outmode)
|
&& HARD_REGNO_MODE_OK (REGNO (XEXP (note, 0)), rld[output_reload].outmode)
|
&& TEST_HARD_REG_BIT (reg_class_contents[(int) rld[output_reload].class],
|
&& TEST_HARD_REG_BIT (reg_class_contents[(int) rld[output_reload].class],
|
REGNO (XEXP (note, 0)))
|
REGNO (XEXP (note, 0)))
|
&& (hard_regno_nregs[REGNO (XEXP (note, 0))][rld[output_reload].outmode]
|
&& (hard_regno_nregs[REGNO (XEXP (note, 0))][rld[output_reload].outmode]
|
<= hard_regno_nregs[REGNO (XEXP (note, 0))][GET_MODE (XEXP (note, 0))])
|
<= hard_regno_nregs[REGNO (XEXP (note, 0))][GET_MODE (XEXP (note, 0))])
|
/* Ensure that a secondary or tertiary reload for this output
|
/* Ensure that a secondary or tertiary reload for this output
|
won't want this register. */
|
won't want this register. */
|
&& ((secondary_out = rld[output_reload].secondary_out_reload) == -1
|
&& ((secondary_out = rld[output_reload].secondary_out_reload) == -1
|
|| (! (TEST_HARD_REG_BIT
|
|| (! (TEST_HARD_REG_BIT
|
(reg_class_contents[(int) rld[secondary_out].class],
|
(reg_class_contents[(int) rld[secondary_out].class],
|
REGNO (XEXP (note, 0))))
|
REGNO (XEXP (note, 0))))
|
&& ((secondary_out = rld[secondary_out].secondary_out_reload) == -1
|
&& ((secondary_out = rld[secondary_out].secondary_out_reload) == -1
|
|| ! (TEST_HARD_REG_BIT
|
|| ! (TEST_HARD_REG_BIT
|
(reg_class_contents[(int) rld[secondary_out].class],
|
(reg_class_contents[(int) rld[secondary_out].class],
|
REGNO (XEXP (note, 0)))))))
|
REGNO (XEXP (note, 0)))))))
|
&& ! fixed_regs[REGNO (XEXP (note, 0))]
|
&& ! fixed_regs[REGNO (XEXP (note, 0))]
|
/* Check that we don't use a hardreg for an uninitialized
|
/* Check that we don't use a hardreg for an uninitialized
|
pseudo. See also find_dummy_reload(). */
|
pseudo. See also find_dummy_reload(). */
|
&& (ORIGINAL_REGNO (XEXP (note, 0)) < FIRST_PSEUDO_REGISTER
|
&& (ORIGINAL_REGNO (XEXP (note, 0)) < FIRST_PSEUDO_REGISTER
|
|| ! bitmap_bit_p (ENTRY_BLOCK_PTR->il.rtl->global_live_at_end,
|
|| ! bitmap_bit_p (ENTRY_BLOCK_PTR->il.rtl->global_live_at_end,
|
ORIGINAL_REGNO (XEXP (note, 0)))))
|
ORIGINAL_REGNO (XEXP (note, 0)))))
|
{
|
{
|
rld[output_reload].reg_rtx
|
rld[output_reload].reg_rtx
|
= gen_rtx_REG (rld[output_reload].outmode,
|
= gen_rtx_REG (rld[output_reload].outmode,
|
REGNO (XEXP (note, 0)));
|
REGNO (XEXP (note, 0)));
|
return;
|
return;
|
}
|
}
|
}
|
}
|
|
|
/* Try to find a reload register for an in-out reload (expressions IN and OUT).
|
/* Try to find a reload register for an in-out reload (expressions IN and OUT).
|
See if one of IN and OUT is a register that may be used;
|
See if one of IN and OUT is a register that may be used;
|
this is desirable since a spill-register won't be needed.
|
this is desirable since a spill-register won't be needed.
|
If so, return the register rtx that proves acceptable.
|
If so, return the register rtx that proves acceptable.
|
|
|
INLOC and OUTLOC are locations where IN and OUT appear in the insn.
|
INLOC and OUTLOC are locations where IN and OUT appear in the insn.
|
CLASS is the register class required for the reload.
|
CLASS is the register class required for the reload.
|
|
|
If FOR_REAL is >= 0, it is the number of the reload,
|
If FOR_REAL is >= 0, it is the number of the reload,
|
and in some cases when it can be discovered that OUT doesn't need
|
and in some cases when it can be discovered that OUT doesn't need
|
to be computed, clear out rld[FOR_REAL].out.
|
to be computed, clear out rld[FOR_REAL].out.
|
|
|
If FOR_REAL is -1, this should not be done, because this call
|
If FOR_REAL is -1, this should not be done, because this call
|
is just to see if a register can be found, not to find and install it.
|
is just to see if a register can be found, not to find and install it.
|
|
|
EARLYCLOBBER is nonzero if OUT is an earlyclobber operand. This
|
EARLYCLOBBER is nonzero if OUT is an earlyclobber operand. This
|
puts an additional constraint on being able to use IN for OUT since
|
puts an additional constraint on being able to use IN for OUT since
|
IN must not appear elsewhere in the insn (it is assumed that IN itself
|
IN must not appear elsewhere in the insn (it is assumed that IN itself
|
is safe from the earlyclobber). */
|
is safe from the earlyclobber). */
|
|
|
static rtx
|
static rtx
|
find_dummy_reload (rtx real_in, rtx real_out, rtx *inloc, rtx *outloc,
|
find_dummy_reload (rtx real_in, rtx real_out, rtx *inloc, rtx *outloc,
|
enum machine_mode inmode, enum machine_mode outmode,
|
enum machine_mode inmode, enum machine_mode outmode,
|
enum reg_class class, int for_real, int earlyclobber)
|
enum reg_class class, int for_real, int earlyclobber)
|
{
|
{
|
rtx in = real_in;
|
rtx in = real_in;
|
rtx out = real_out;
|
rtx out = real_out;
|
int in_offset = 0;
|
int in_offset = 0;
|
int out_offset = 0;
|
int out_offset = 0;
|
rtx value = 0;
|
rtx value = 0;
|
|
|
/* If operands exceed a word, we can't use either of them
|
/* If operands exceed a word, we can't use either of them
|
unless they have the same size. */
|
unless they have the same size. */
|
if (GET_MODE_SIZE (outmode) != GET_MODE_SIZE (inmode)
|
if (GET_MODE_SIZE (outmode) != GET_MODE_SIZE (inmode)
|
&& (GET_MODE_SIZE (outmode) > UNITS_PER_WORD
|
&& (GET_MODE_SIZE (outmode) > UNITS_PER_WORD
|
|| GET_MODE_SIZE (inmode) > UNITS_PER_WORD))
|
|| GET_MODE_SIZE (inmode) > UNITS_PER_WORD))
|
return 0;
|
return 0;
|
|
|
/* Note that {in,out}_offset are needed only when 'in' or 'out'
|
/* Note that {in,out}_offset are needed only when 'in' or 'out'
|
respectively refers to a hard register. */
|
respectively refers to a hard register. */
|
|
|
/* Find the inside of any subregs. */
|
/* Find the inside of any subregs. */
|
while (GET_CODE (out) == SUBREG)
|
while (GET_CODE (out) == SUBREG)
|
{
|
{
|
if (REG_P (SUBREG_REG (out))
|
if (REG_P (SUBREG_REG (out))
|
&& REGNO (SUBREG_REG (out)) < FIRST_PSEUDO_REGISTER)
|
&& REGNO (SUBREG_REG (out)) < FIRST_PSEUDO_REGISTER)
|
out_offset += subreg_regno_offset (REGNO (SUBREG_REG (out)),
|
out_offset += subreg_regno_offset (REGNO (SUBREG_REG (out)),
|
GET_MODE (SUBREG_REG (out)),
|
GET_MODE (SUBREG_REG (out)),
|
SUBREG_BYTE (out),
|
SUBREG_BYTE (out),
|
GET_MODE (out));
|
GET_MODE (out));
|
out = SUBREG_REG (out);
|
out = SUBREG_REG (out);
|
}
|
}
|
while (GET_CODE (in) == SUBREG)
|
while (GET_CODE (in) == SUBREG)
|
{
|
{
|
if (REG_P (SUBREG_REG (in))
|
if (REG_P (SUBREG_REG (in))
|
&& REGNO (SUBREG_REG (in)) < FIRST_PSEUDO_REGISTER)
|
&& REGNO (SUBREG_REG (in)) < FIRST_PSEUDO_REGISTER)
|
in_offset += subreg_regno_offset (REGNO (SUBREG_REG (in)),
|
in_offset += subreg_regno_offset (REGNO (SUBREG_REG (in)),
|
GET_MODE (SUBREG_REG (in)),
|
GET_MODE (SUBREG_REG (in)),
|
SUBREG_BYTE (in),
|
SUBREG_BYTE (in),
|
GET_MODE (in));
|
GET_MODE (in));
|
in = SUBREG_REG (in);
|
in = SUBREG_REG (in);
|
}
|
}
|
|
|
/* Narrow down the reg class, the same way push_reload will;
|
/* Narrow down the reg class, the same way push_reload will;
|
otherwise we might find a dummy now, but push_reload won't. */
|
otherwise we might find a dummy now, but push_reload won't. */
|
{
|
{
|
enum reg_class preferred_class = PREFERRED_RELOAD_CLASS (in, class);
|
enum reg_class preferred_class = PREFERRED_RELOAD_CLASS (in, class);
|
if (preferred_class != NO_REGS)
|
if (preferred_class != NO_REGS)
|
class = preferred_class;
|
class = preferred_class;
|
}
|
}
|
|
|
/* See if OUT will do. */
|
/* See if OUT will do. */
|
if (REG_P (out)
|
if (REG_P (out)
|
&& REGNO (out) < FIRST_PSEUDO_REGISTER)
|
&& REGNO (out) < FIRST_PSEUDO_REGISTER)
|
{
|
{
|
unsigned int regno = REGNO (out) + out_offset;
|
unsigned int regno = REGNO (out) + out_offset;
|
unsigned int nwords = hard_regno_nregs[regno][outmode];
|
unsigned int nwords = hard_regno_nregs[regno][outmode];
|
rtx saved_rtx;
|
rtx saved_rtx;
|
|
|
/* When we consider whether the insn uses OUT,
|
/* When we consider whether the insn uses OUT,
|
ignore references within IN. They don't prevent us
|
ignore references within IN. They don't prevent us
|
from copying IN into OUT, because those refs would
|
from copying IN into OUT, because those refs would
|
move into the insn that reloads IN.
|
move into the insn that reloads IN.
|
|
|
However, we only ignore IN in its role as this reload.
|
However, we only ignore IN in its role as this reload.
|
If the insn uses IN elsewhere and it contains OUT,
|
If the insn uses IN elsewhere and it contains OUT,
|
that counts. We can't be sure it's the "same" operand
|
that counts. We can't be sure it's the "same" operand
|
so it might not go through this reload. */
|
so it might not go through this reload. */
|
saved_rtx = *inloc;
|
saved_rtx = *inloc;
|
*inloc = const0_rtx;
|
*inloc = const0_rtx;
|
|
|
if (regno < FIRST_PSEUDO_REGISTER
|
if (regno < FIRST_PSEUDO_REGISTER
|
&& HARD_REGNO_MODE_OK (regno, outmode)
|
&& HARD_REGNO_MODE_OK (regno, outmode)
|
&& ! refers_to_regno_for_reload_p (regno, regno + nwords,
|
&& ! refers_to_regno_for_reload_p (regno, regno + nwords,
|
PATTERN (this_insn), outloc))
|
PATTERN (this_insn), outloc))
|
{
|
{
|
unsigned int i;
|
unsigned int i;
|
|
|
for (i = 0; i < nwords; i++)
|
for (i = 0; i < nwords; i++)
|
if (! TEST_HARD_REG_BIT (reg_class_contents[(int) class],
|
if (! TEST_HARD_REG_BIT (reg_class_contents[(int) class],
|
regno + i))
|
regno + i))
|
break;
|
break;
|
|
|
if (i == nwords)
|
if (i == nwords)
|
{
|
{
|
if (REG_P (real_out))
|
if (REG_P (real_out))
|
value = real_out;
|
value = real_out;
|
else
|
else
|
value = gen_rtx_REG (outmode, regno);
|
value = gen_rtx_REG (outmode, regno);
|
}
|
}
|
}
|
}
|
|
|
*inloc = saved_rtx;
|
*inloc = saved_rtx;
|
}
|
}
|
|
|
/* Consider using IN if OUT was not acceptable
|
/* Consider using IN if OUT was not acceptable
|
or if OUT dies in this insn (like the quotient in a divmod insn).
|
or if OUT dies in this insn (like the quotient in a divmod insn).
|
We can't use IN unless it is dies in this insn,
|
We can't use IN unless it is dies in this insn,
|
which means we must know accurately which hard regs are live.
|
which means we must know accurately which hard regs are live.
|
Also, the result can't go in IN if IN is used within OUT,
|
Also, the result can't go in IN if IN is used within OUT,
|
or if OUT is an earlyclobber and IN appears elsewhere in the insn. */
|
or if OUT is an earlyclobber and IN appears elsewhere in the insn. */
|
if (hard_regs_live_known
|
if (hard_regs_live_known
|
&& REG_P (in)
|
&& REG_P (in)
|
&& REGNO (in) < FIRST_PSEUDO_REGISTER
|
&& REGNO (in) < FIRST_PSEUDO_REGISTER
|
&& (value == 0
|
&& (value == 0
|
|| find_reg_note (this_insn, REG_UNUSED, real_out))
|
|| find_reg_note (this_insn, REG_UNUSED, real_out))
|
&& find_reg_note (this_insn, REG_DEAD, real_in)
|
&& find_reg_note (this_insn, REG_DEAD, real_in)
|
&& !fixed_regs[REGNO (in)]
|
&& !fixed_regs[REGNO (in)]
|
&& HARD_REGNO_MODE_OK (REGNO (in),
|
&& HARD_REGNO_MODE_OK (REGNO (in),
|
/* The only case where out and real_out might
|
/* The only case where out and real_out might
|
have different modes is where real_out
|
have different modes is where real_out
|
is a subreg, and in that case, out
|
is a subreg, and in that case, out
|
has a real mode. */
|
has a real mode. */
|
(GET_MODE (out) != VOIDmode
|
(GET_MODE (out) != VOIDmode
|
? GET_MODE (out) : outmode))
|
? GET_MODE (out) : outmode))
|
/* But only do all this if we can be sure, that this input
|
/* But only do all this if we can be sure, that this input
|
operand doesn't correspond with an uninitialized pseudoreg.
|
operand doesn't correspond with an uninitialized pseudoreg.
|
global can assign some hardreg to it, which is the same as
|
global can assign some hardreg to it, which is the same as
|
a different pseudo also currently live (as it can ignore the
|
a different pseudo also currently live (as it can ignore the
|
conflict). So we never must introduce writes to such hardregs,
|
conflict). So we never must introduce writes to such hardregs,
|
as they would clobber the other live pseudo using the same.
|
as they would clobber the other live pseudo using the same.
|
See also PR20973. */
|
See also PR20973. */
|
&& (ORIGINAL_REGNO (in) < FIRST_PSEUDO_REGISTER
|
&& (ORIGINAL_REGNO (in) < FIRST_PSEUDO_REGISTER
|
|| ! bitmap_bit_p (ENTRY_BLOCK_PTR->il.rtl->global_live_at_end,
|
|| ! bitmap_bit_p (ENTRY_BLOCK_PTR->il.rtl->global_live_at_end,
|
ORIGINAL_REGNO (in))))
|
ORIGINAL_REGNO (in))))
|
{
|
{
|
unsigned int regno = REGNO (in) + in_offset;
|
unsigned int regno = REGNO (in) + in_offset;
|
unsigned int nwords = hard_regno_nregs[regno][inmode];
|
unsigned int nwords = hard_regno_nregs[regno][inmode];
|
|
|
if (! refers_to_regno_for_reload_p (regno, regno + nwords, out, (rtx*) 0)
|
if (! refers_to_regno_for_reload_p (regno, regno + nwords, out, (rtx*) 0)
|
&& ! hard_reg_set_here_p (regno, regno + nwords,
|
&& ! hard_reg_set_here_p (regno, regno + nwords,
|
PATTERN (this_insn))
|
PATTERN (this_insn))
|
&& (! earlyclobber
|
&& (! earlyclobber
|
|| ! refers_to_regno_for_reload_p (regno, regno + nwords,
|
|| ! refers_to_regno_for_reload_p (regno, regno + nwords,
|
PATTERN (this_insn), inloc)))
|
PATTERN (this_insn), inloc)))
|
{
|
{
|
unsigned int i;
|
unsigned int i;
|
|
|
for (i = 0; i < nwords; i++)
|
for (i = 0; i < nwords; i++)
|
if (! TEST_HARD_REG_BIT (reg_class_contents[(int) class],
|
if (! TEST_HARD_REG_BIT (reg_class_contents[(int) class],
|
regno + i))
|
regno + i))
|
break;
|
break;
|
|
|
if (i == nwords)
|
if (i == nwords)
|
{
|
{
|
/* If we were going to use OUT as the reload reg
|
/* If we were going to use OUT as the reload reg
|
and changed our mind, it means OUT is a dummy that
|
and changed our mind, it means OUT is a dummy that
|
dies here. So don't bother copying value to it. */
|
dies here. So don't bother copying value to it. */
|
if (for_real >= 0 && value == real_out)
|
if (for_real >= 0 && value == real_out)
|
rld[for_real].out = 0;
|
rld[for_real].out = 0;
|
if (REG_P (real_in))
|
if (REG_P (real_in))
|
value = real_in;
|
value = real_in;
|
else
|
else
|
value = gen_rtx_REG (inmode, regno);
|
value = gen_rtx_REG (inmode, regno);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
return value;
|
return value;
|
}
|
}
|
|
|
/* This page contains subroutines used mainly for determining
|
/* This page contains subroutines used mainly for determining
|
whether the IN or an OUT of a reload can serve as the
|
whether the IN or an OUT of a reload can serve as the
|
reload register. */
|
reload register. */
|
|
|
/* Return 1 if X is an operand of an insn that is being earlyclobbered. */
|
/* Return 1 if X is an operand of an insn that is being earlyclobbered. */
|
|
|
int
|
int
|
earlyclobber_operand_p (rtx x)
|
earlyclobber_operand_p (rtx x)
|
{
|
{
|
int i;
|
int i;
|
|
|
for (i = 0; i < n_earlyclobbers; i++)
|
for (i = 0; i < n_earlyclobbers; i++)
|
if (reload_earlyclobbers[i] == x)
|
if (reload_earlyclobbers[i] == x)
|
return 1;
|
return 1;
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Return 1 if expression X alters a hard reg in the range
|
/* Return 1 if expression X alters a hard reg in the range
|
from BEG_REGNO (inclusive) to END_REGNO (exclusive),
|
from BEG_REGNO (inclusive) to END_REGNO (exclusive),
|
either explicitly or in the guise of a pseudo-reg allocated to REGNO.
|
either explicitly or in the guise of a pseudo-reg allocated to REGNO.
|
X should be the body of an instruction. */
|
X should be the body of an instruction. */
|
|
|
static int
|
static int
|
hard_reg_set_here_p (unsigned int beg_regno, unsigned int 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)
|
if (GET_CODE (x) == SET || GET_CODE (x) == CLOBBER)
|
{
|
{
|
rtx op0 = SET_DEST (x);
|
rtx op0 = SET_DEST (x);
|
|
|
while (GET_CODE (op0) == SUBREG)
|
while (GET_CODE (op0) == SUBREG)
|
op0 = SUBREG_REG (op0);
|
op0 = SUBREG_REG (op0);
|
if (REG_P (op0))
|
if (REG_P (op0))
|
{
|
{
|
unsigned int r = REGNO (op0);
|
unsigned int r = REGNO (op0);
|
|
|
/* See if this reg overlaps range under consideration. */
|
/* See if this reg overlaps range under consideration. */
|
if (r < end_regno
|
if (r < end_regno
|
&& r + hard_regno_nregs[r][GET_MODE (op0)] > beg_regno)
|
&& r + hard_regno_nregs[r][GET_MODE (op0)] > beg_regno)
|
return 1;
|
return 1;
|
}
|
}
|
}
|
}
|
else if (GET_CODE (x) == PARALLEL)
|
else if (GET_CODE (x) == PARALLEL)
|
{
|
{
|
int i = XVECLEN (x, 0) - 1;
|
int i = XVECLEN (x, 0) - 1;
|
|
|
for (; i >= 0; i--)
|
for (; i >= 0; i--)
|
if (hard_reg_set_here_p (beg_regno, end_regno, XVECEXP (x, 0, i)))
|
if (hard_reg_set_here_p (beg_regno, end_regno, XVECEXP (x, 0, i)))
|
return 1;
|
return 1;
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Return 1 if ADDR is a valid memory address for mode MODE,
|
/* Return 1 if ADDR is a valid memory address for mode MODE,
|
and check that each pseudo reg has the proper kind of
|
and check that each pseudo reg has the proper kind of
|
hard reg. */
|
hard reg. */
|
|
|
int
|
int
|
strict_memory_address_p (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);
|
GO_IF_LEGITIMATE_ADDRESS (mode, addr, win);
|
return 0;
|
return 0;
|
|
|
win:
|
win:
|
return 1;
|
return 1;
|
}
|
}
|
|
|
/* Like rtx_equal_p except that it allows a REG and a SUBREG to match
|
/* Like rtx_equal_p except that it allows a REG and a SUBREG to match
|
if they are the same hard reg, and has special hacks for
|
if they are the same hard reg, and has special hacks for
|
autoincrement and autodecrement.
|
autoincrement and autodecrement.
|
This is specifically intended for find_reloads to use
|
This is specifically intended for find_reloads to use
|
in determining whether two operands match.
|
in determining whether two operands match.
|
X is the operand whose number is the lower of the two.
|
X is the operand whose number is the lower of the two.
|
|
|
The value is 2 if Y contains a pre-increment that matches
|
The value is 2 if Y contains a pre-increment that matches
|
a non-incrementing address in X. */
|
a non-incrementing address in X. */
|
|
|
/* ??? To be completely correct, we should arrange to pass
|
/* ??? To be completely correct, we should arrange to pass
|
for X the output operand and for Y the input operand.
|
for X the output operand and for Y the input operand.
|
For now, we assume that the output operand has the lower number
|
For now, we assume that the output operand has the lower number
|
because that is natural in (SET output (... input ...)). */
|
because that is natural in (SET output (... input ...)). */
|
|
|
int
|
int
|
operands_match_p (rtx x, rtx y)
|
operands_match_p (rtx x, rtx y)
|
{
|
{
|
int i;
|
int i;
|
RTX_CODE code = GET_CODE (x);
|
RTX_CODE code = GET_CODE (x);
|
const char *fmt;
|
const char *fmt;
|
int success_2;
|
int success_2;
|
|
|
if (x == y)
|
if (x == y)
|
return 1;
|
return 1;
|
if ((code == REG || (code == SUBREG && REG_P (SUBREG_REG (x))))
|
if ((code == REG || (code == SUBREG && REG_P (SUBREG_REG (x))))
|
&& (REG_P (y) || (GET_CODE (y) == SUBREG
|
&& (REG_P (y) || (GET_CODE (y) == SUBREG
|
&& REG_P (SUBREG_REG (y)))))
|
&& REG_P (SUBREG_REG (y)))))
|
{
|
{
|
int j;
|
int j;
|
|
|
if (code == SUBREG)
|
if (code == SUBREG)
|
{
|
{
|
i = REGNO (SUBREG_REG (x));
|
i = REGNO (SUBREG_REG (x));
|
if (i >= FIRST_PSEUDO_REGISTER)
|
if (i >= FIRST_PSEUDO_REGISTER)
|
goto slow;
|
goto slow;
|
i += subreg_regno_offset (REGNO (SUBREG_REG (x)),
|
i += subreg_regno_offset (REGNO (SUBREG_REG (x)),
|
GET_MODE (SUBREG_REG (x)),
|
GET_MODE (SUBREG_REG (x)),
|
SUBREG_BYTE (x),
|
SUBREG_BYTE (x),
|
GET_MODE (x));
|
GET_MODE (x));
|
}
|
}
|
else
|
else
|
i = REGNO (x);
|
i = REGNO (x);
|
|
|
if (GET_CODE (y) == SUBREG)
|
if (GET_CODE (y) == SUBREG)
|
{
|
{
|
j = REGNO (SUBREG_REG (y));
|
j = REGNO (SUBREG_REG (y));
|
if (j >= FIRST_PSEUDO_REGISTER)
|
if (j >= FIRST_PSEUDO_REGISTER)
|
goto slow;
|
goto slow;
|
j += subreg_regno_offset (REGNO (SUBREG_REG (y)),
|
j += subreg_regno_offset (REGNO (SUBREG_REG (y)),
|
GET_MODE (SUBREG_REG (y)),
|
GET_MODE (SUBREG_REG (y)),
|
SUBREG_BYTE (y),
|
SUBREG_BYTE (y),
|
GET_MODE (y));
|
GET_MODE (y));
|
}
|
}
|
else
|
else
|
j = REGNO (y);
|
j = REGNO (y);
|
|
|
/* On a WORDS_BIG_ENDIAN machine, point to the last register of a
|
/* On a WORDS_BIG_ENDIAN machine, point to the last register of a
|
multiple hard register group of scalar integer registers, so that
|
multiple hard register group of scalar integer registers, so that
|
for example (reg:DI 0) and (reg:SI 1) will be considered the same
|
for example (reg:DI 0) and (reg:SI 1) will be considered the same
|
register. */
|
register. */
|
if (WORDS_BIG_ENDIAN && GET_MODE_SIZE (GET_MODE (x)) > UNITS_PER_WORD
|
if (WORDS_BIG_ENDIAN && GET_MODE_SIZE (GET_MODE (x)) > UNITS_PER_WORD
|
&& SCALAR_INT_MODE_P (GET_MODE (x))
|
&& SCALAR_INT_MODE_P (GET_MODE (x))
|
&& i < FIRST_PSEUDO_REGISTER)
|
&& i < FIRST_PSEUDO_REGISTER)
|
i += hard_regno_nregs[i][GET_MODE (x)] - 1;
|
i += hard_regno_nregs[i][GET_MODE (x)] - 1;
|
if (WORDS_BIG_ENDIAN && GET_MODE_SIZE (GET_MODE (y)) > UNITS_PER_WORD
|
if (WORDS_BIG_ENDIAN && GET_MODE_SIZE (GET_MODE (y)) > UNITS_PER_WORD
|
&& SCALAR_INT_MODE_P (GET_MODE (y))
|
&& SCALAR_INT_MODE_P (GET_MODE (y))
|
&& j < FIRST_PSEUDO_REGISTER)
|
&& j < FIRST_PSEUDO_REGISTER)
|
j += hard_regno_nregs[j][GET_MODE (y)] - 1;
|
j += hard_regno_nregs[j][GET_MODE (y)] - 1;
|
|
|
return i == j;
|
return i == j;
|
}
|
}
|
/* If two operands must match, because they are really a single
|
/* If two operands must match, because they are really a single
|
operand of an assembler insn, then two postincrements are invalid
|
operand of an assembler insn, then two postincrements are invalid
|
because the assembler insn would increment only once.
|
because the assembler insn would increment only once.
|
On the other hand, a postincrement matches ordinary indexing
|
On the other hand, a postincrement matches ordinary indexing
|
if the postincrement is the output operand. */
|
if the postincrement is the output operand. */
|
if (code == POST_DEC || code == POST_INC || code == POST_MODIFY)
|
if (code == POST_DEC || code == POST_INC || code == POST_MODIFY)
|
return operands_match_p (XEXP (x, 0), y);
|
return operands_match_p (XEXP (x, 0), y);
|
/* Two preincrements are invalid
|
/* Two preincrements are invalid
|
because the assembler insn would increment only once.
|
because the assembler insn would increment only once.
|
On the other hand, a preincrement matches ordinary indexing
|
On the other hand, a preincrement matches ordinary indexing
|
if the preincrement is the input operand.
|
if the preincrement is the input operand.
|
In this case, return 2, since some callers need to do special
|
In this case, return 2, since some callers need to do special
|
things when this happens. */
|
things when this happens. */
|
if (GET_CODE (y) == PRE_DEC || GET_CODE (y) == PRE_INC
|
if (GET_CODE (y) == PRE_DEC || GET_CODE (y) == PRE_INC
|
|| GET_CODE (y) == PRE_MODIFY)
|
|| GET_CODE (y) == PRE_MODIFY)
|
return operands_match_p (x, XEXP (y, 0)) ? 2 : 0;
|
return operands_match_p (x, XEXP (y, 0)) ? 2 : 0;
|
|
|
slow:
|
slow:
|
|
|
/* Now we have disposed of all the cases in which different rtx codes
|
/* Now we have disposed of all the cases in which different rtx codes
|
can match. */
|
can match. */
|
if (code != GET_CODE (y))
|
if (code != GET_CODE (y))
|
return 0;
|
return 0;
|
|
|
/* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent. */
|
/* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent. */
|
if (GET_MODE (x) != GET_MODE (y))
|
if (GET_MODE (x) != GET_MODE (y))
|
return 0;
|
return 0;
|
|
|
switch (code)
|
switch (code)
|
{
|
{
|
case CONST_INT:
|
case CONST_INT:
|
case CONST_DOUBLE:
|
case CONST_DOUBLE:
|
return 0;
|
return 0;
|
|
|
case LABEL_REF:
|
case LABEL_REF:
|
return XEXP (x, 0) == XEXP (y, 0);
|
return XEXP (x, 0) == XEXP (y, 0);
|
case SYMBOL_REF:
|
case SYMBOL_REF:
|
return XSTR (x, 0) == XSTR (y, 0);
|
return XSTR (x, 0) == XSTR (y, 0);
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
/* Compare the elements. If any pair of corresponding elements
|
/* Compare the elements. If any pair of corresponding elements
|
fail to match, return 0 for the whole things. */
|
fail to match, return 0 for the whole things. */
|
|
|
success_2 = 0;
|
success_2 = 0;
|
fmt = GET_RTX_FORMAT (code);
|
fmt = GET_RTX_FORMAT (code);
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
{
|
{
|
int val, j;
|
int val, j;
|
switch (fmt[i])
|
switch (fmt[i])
|
{
|
{
|
case 'w':
|
case 'w':
|
if (XWINT (x, i) != XWINT (y, i))
|
if (XWINT (x, i) != XWINT (y, i))
|
return 0;
|
return 0;
|
break;
|
break;
|
|
|
case 'i':
|
case 'i':
|
if (XINT (x, i) != XINT (y, i))
|
if (XINT (x, i) != XINT (y, i))
|
return 0;
|
return 0;
|
break;
|
break;
|
|
|
case 'e':
|
case 'e':
|
val = operands_match_p (XEXP (x, i), XEXP (y, i));
|
val = operands_match_p (XEXP (x, i), XEXP (y, i));
|
if (val == 0)
|
if (val == 0)
|
return 0;
|
return 0;
|
/* If any subexpression returns 2,
|
/* If any subexpression returns 2,
|
we should return 2 if we are successful. */
|
we should return 2 if we are successful. */
|
if (val == 2)
|
if (val == 2)
|
success_2 = 1;
|
success_2 = 1;
|
break;
|
break;
|
|
|
case '0':
|
case '0':
|
break;
|
break;
|
|
|
case 'E':
|
case 'E':
|
if (XVECLEN (x, i) != XVECLEN (y, i))
|
if (XVECLEN (x, i) != XVECLEN (y, i))
|
return 0;
|
return 0;
|
for (j = XVECLEN (x, i) - 1; j >= 0; --j)
|
for (j = XVECLEN (x, i) - 1; j >= 0; --j)
|
{
|
{
|
val = operands_match_p (XVECEXP (x, i, j), XVECEXP (y, i, j));
|
val = operands_match_p (XVECEXP (x, i, j), XVECEXP (y, i, j));
|
if (val == 0)
|
if (val == 0)
|
return 0;
|
return 0;
|
if (val == 2)
|
if (val == 2)
|
success_2 = 1;
|
success_2 = 1;
|
}
|
}
|
break;
|
break;
|
|
|
/* It is believed that rtx's at this level will never
|
/* It is believed that rtx's at this level will never
|
contain anything but integers and other rtx's,
|
contain anything but integers and other rtx's,
|
except for within LABEL_REFs and SYMBOL_REFs. */
|
except for within LABEL_REFs and SYMBOL_REFs. */
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
}
|
}
|
return 1 + success_2;
|
return 1 + success_2;
|
}
|
}
|
|
|
/* Describe the range of registers or memory referenced by X.
|
/* Describe the range of registers or memory referenced by X.
|
If X is a register, set REG_FLAG and put the first register
|
If X is a register, set REG_FLAG and put the first register
|
number into START and the last plus one into END.
|
number into START and the last plus one into END.
|
If X is a memory reference, put a base address into BASE
|
If X is a memory reference, put a base address into BASE
|
and a range of integer offsets into START and END.
|
and a range of integer offsets into START and END.
|
If X is pushing on the stack, we can assume it causes no trouble,
|
If X is pushing on the stack, we can assume it causes no trouble,
|
so we set the SAFE field. */
|
so we set the SAFE field. */
|
|
|
static struct decomposition
|
static struct decomposition
|
decompose (rtx x)
|
decompose (rtx x)
|
{
|
{
|
struct decomposition val;
|
struct decomposition val;
|
int all_const = 0;
|
int all_const = 0;
|
|
|
memset (&val, 0, sizeof (val));
|
memset (&val, 0, sizeof (val));
|
|
|
switch (GET_CODE (x))
|
switch (GET_CODE (x))
|
{
|
{
|
case MEM:
|
case MEM:
|
{
|
{
|
rtx base = NULL_RTX, offset = 0;
|
rtx base = NULL_RTX, offset = 0;
|
rtx addr = XEXP (x, 0);
|
rtx addr = XEXP (x, 0);
|
|
|
if (GET_CODE (addr) == PRE_DEC || GET_CODE (addr) == PRE_INC
|
if (GET_CODE (addr) == PRE_DEC || GET_CODE (addr) == PRE_INC
|
|| GET_CODE (addr) == POST_DEC || GET_CODE (addr) == POST_INC)
|
|| GET_CODE (addr) == POST_DEC || GET_CODE (addr) == POST_INC)
|
{
|
{
|
val.base = XEXP (addr, 0);
|
val.base = XEXP (addr, 0);
|
val.start = -GET_MODE_SIZE (GET_MODE (x));
|
val.start = -GET_MODE_SIZE (GET_MODE (x));
|
val.end = GET_MODE_SIZE (GET_MODE (x));
|
val.end = GET_MODE_SIZE (GET_MODE (x));
|
val.safe = REGNO (val.base) == STACK_POINTER_REGNUM;
|
val.safe = REGNO (val.base) == STACK_POINTER_REGNUM;
|
return val;
|
return val;
|
}
|
}
|
|
|
if (GET_CODE (addr) == PRE_MODIFY || GET_CODE (addr) == POST_MODIFY)
|
if (GET_CODE (addr) == PRE_MODIFY || GET_CODE (addr) == POST_MODIFY)
|
{
|
{
|
if (GET_CODE (XEXP (addr, 1)) == PLUS
|
if (GET_CODE (XEXP (addr, 1)) == PLUS
|
&& XEXP (addr, 0) == XEXP (XEXP (addr, 1), 0)
|
&& XEXP (addr, 0) == XEXP (XEXP (addr, 1), 0)
|
&& CONSTANT_P (XEXP (XEXP (addr, 1), 1)))
|
&& CONSTANT_P (XEXP (XEXP (addr, 1), 1)))
|
{
|
{
|
val.base = XEXP (addr, 0);
|
val.base = XEXP (addr, 0);
|
val.start = -INTVAL (XEXP (XEXP (addr, 1), 1));
|
val.start = -INTVAL (XEXP (XEXP (addr, 1), 1));
|
val.end = INTVAL (XEXP (XEXP (addr, 1), 1));
|
val.end = INTVAL (XEXP (XEXP (addr, 1), 1));
|
val.safe = REGNO (val.base) == STACK_POINTER_REGNUM;
|
val.safe = REGNO (val.base) == STACK_POINTER_REGNUM;
|
return val;
|
return val;
|
}
|
}
|
}
|
}
|
|
|
if (GET_CODE (addr) == CONST)
|
if (GET_CODE (addr) == CONST)
|
{
|
{
|
addr = XEXP (addr, 0);
|
addr = XEXP (addr, 0);
|
all_const = 1;
|
all_const = 1;
|
}
|
}
|
if (GET_CODE (addr) == PLUS)
|
if (GET_CODE (addr) == PLUS)
|
{
|
{
|
if (CONSTANT_P (XEXP (addr, 0)))
|
if (CONSTANT_P (XEXP (addr, 0)))
|
{
|
{
|
base = XEXP (addr, 1);
|
base = XEXP (addr, 1);
|
offset = XEXP (addr, 0);
|
offset = XEXP (addr, 0);
|
}
|
}
|
else if (CONSTANT_P (XEXP (addr, 1)))
|
else if (CONSTANT_P (XEXP (addr, 1)))
|
{
|
{
|
base = XEXP (addr, 0);
|
base = XEXP (addr, 0);
|
offset = XEXP (addr, 1);
|
offset = XEXP (addr, 1);
|
}
|
}
|
}
|
}
|
|
|
if (offset == 0)
|
if (offset == 0)
|
{
|
{
|
base = addr;
|
base = addr;
|
offset = const0_rtx;
|
offset = const0_rtx;
|
}
|
}
|
if (GET_CODE (offset) == CONST)
|
if (GET_CODE (offset) == CONST)
|
offset = XEXP (offset, 0);
|
offset = XEXP (offset, 0);
|
if (GET_CODE (offset) == PLUS)
|
if (GET_CODE (offset) == PLUS)
|
{
|
{
|
if (GET_CODE (XEXP (offset, 0)) == CONST_INT)
|
if (GET_CODE (XEXP (offset, 0)) == CONST_INT)
|
{
|
{
|
base = gen_rtx_PLUS (GET_MODE (base), base, XEXP (offset, 1));
|
base = gen_rtx_PLUS (GET_MODE (base), base, XEXP (offset, 1));
|
offset = XEXP (offset, 0);
|
offset = XEXP (offset, 0);
|
}
|
}
|
else if (GET_CODE (XEXP (offset, 1)) == CONST_INT)
|
else if (GET_CODE (XEXP (offset, 1)) == CONST_INT)
|
{
|
{
|
base = gen_rtx_PLUS (GET_MODE (base), base, XEXP (offset, 0));
|
base = gen_rtx_PLUS (GET_MODE (base), base, XEXP (offset, 0));
|
offset = XEXP (offset, 1);
|
offset = XEXP (offset, 1);
|
}
|
}
|
else
|
else
|
{
|
{
|
base = gen_rtx_PLUS (GET_MODE (base), base, offset);
|
base = gen_rtx_PLUS (GET_MODE (base), base, offset);
|
offset = const0_rtx;
|
offset = const0_rtx;
|
}
|
}
|
}
|
}
|
else if (GET_CODE (offset) != CONST_INT)
|
else if (GET_CODE (offset) != CONST_INT)
|
{
|
{
|
base = gen_rtx_PLUS (GET_MODE (base), base, offset);
|
base = gen_rtx_PLUS (GET_MODE (base), base, offset);
|
offset = const0_rtx;
|
offset = const0_rtx;
|
}
|
}
|
|
|
if (all_const && GET_CODE (base) == PLUS)
|
if (all_const && GET_CODE (base) == PLUS)
|
base = gen_rtx_CONST (GET_MODE (base), base);
|
base = gen_rtx_CONST (GET_MODE (base), base);
|
|
|
gcc_assert (GET_CODE (offset) == CONST_INT);
|
gcc_assert (GET_CODE (offset) == CONST_INT);
|
|
|
val.start = INTVAL (offset);
|
val.start = INTVAL (offset);
|
val.end = val.start + GET_MODE_SIZE (GET_MODE (x));
|
val.end = val.start + GET_MODE_SIZE (GET_MODE (x));
|
val.base = base;
|
val.base = base;
|
}
|
}
|
break;
|
break;
|
|
|
case REG:
|
case REG:
|
val.reg_flag = 1;
|
val.reg_flag = 1;
|
val.start = true_regnum (x);
|
val.start = true_regnum (x);
|
if (val.start < 0 || val.start >= FIRST_PSEUDO_REGISTER)
|
if (val.start < 0 || val.start >= FIRST_PSEUDO_REGISTER)
|
{
|
{
|
/* A pseudo with no hard reg. */
|
/* A pseudo with no hard reg. */
|
val.start = REGNO (x);
|
val.start = REGNO (x);
|
val.end = val.start + 1;
|
val.end = val.start + 1;
|
}
|
}
|
else
|
else
|
/* A hard reg. */
|
/* A hard reg. */
|
val.end = val.start + hard_regno_nregs[val.start][GET_MODE (x)];
|
val.end = val.start + hard_regno_nregs[val.start][GET_MODE (x)];
|
break;
|
break;
|
|
|
case SUBREG:
|
case SUBREG:
|
if (!REG_P (SUBREG_REG (x)))
|
if (!REG_P (SUBREG_REG (x)))
|
/* This could be more precise, but it's good enough. */
|
/* This could be more precise, but it's good enough. */
|
return decompose (SUBREG_REG (x));
|
return decompose (SUBREG_REG (x));
|
val.reg_flag = 1;
|
val.reg_flag = 1;
|
val.start = true_regnum (x);
|
val.start = true_regnum (x);
|
if (val.start < 0 || val.start >= FIRST_PSEUDO_REGISTER)
|
if (val.start < 0 || val.start >= FIRST_PSEUDO_REGISTER)
|
return decompose (SUBREG_REG (x));
|
return decompose (SUBREG_REG (x));
|
else
|
else
|
/* A hard reg. */
|
/* A hard reg. */
|
val.end = val.start + hard_regno_nregs[val.start][GET_MODE (x)];
|
val.end = val.start + hard_regno_nregs[val.start][GET_MODE (x)];
|
break;
|
break;
|
|
|
case SCRATCH:
|
case SCRATCH:
|
/* This hasn't been assigned yet, so it can't conflict yet. */
|
/* This hasn't been assigned yet, so it can't conflict yet. */
|
val.safe = 1;
|
val.safe = 1;
|
break;
|
break;
|
|
|
default:
|
default:
|
gcc_assert (CONSTANT_P (x));
|
gcc_assert (CONSTANT_P (x));
|
val.safe = 1;
|
val.safe = 1;
|
break;
|
break;
|
}
|
}
|
return val;
|
return val;
|
}
|
}
|
|
|
/* Return 1 if altering Y will not modify the value of X.
|
/* Return 1 if altering Y will not modify the value of X.
|
Y is also described by YDATA, which should be decompose (Y). */
|
Y is also described by YDATA, which should be decompose (Y). */
|
|
|
static int
|
static int
|
immune_p (rtx x, rtx y, struct decomposition ydata)
|
immune_p (rtx x, rtx y, struct decomposition ydata)
|
{
|
{
|
struct decomposition xdata;
|
struct decomposition xdata;
|
|
|
if (ydata.reg_flag)
|
if (ydata.reg_flag)
|
return !refers_to_regno_for_reload_p (ydata.start, ydata.end, x, (rtx*) 0);
|
return !refers_to_regno_for_reload_p (ydata.start, ydata.end, x, (rtx*) 0);
|
if (ydata.safe)
|
if (ydata.safe)
|
return 1;
|
return 1;
|
|
|
gcc_assert (MEM_P (y));
|
gcc_assert (MEM_P (y));
|
/* If Y is memory and X is not, Y can't affect X. */
|
/* If Y is memory and X is not, Y can't affect X. */
|
if (!MEM_P (x))
|
if (!MEM_P (x))
|
return 1;
|
return 1;
|
|
|
xdata = decompose (x);
|
xdata = decompose (x);
|
|
|
if (! rtx_equal_p (xdata.base, ydata.base))
|
if (! rtx_equal_p (xdata.base, ydata.base))
|
{
|
{
|
/* If bases are distinct symbolic constants, there is no overlap. */
|
/* If bases are distinct symbolic constants, there is no overlap. */
|
if (CONSTANT_P (xdata.base) && CONSTANT_P (ydata.base))
|
if (CONSTANT_P (xdata.base) && CONSTANT_P (ydata.base))
|
return 1;
|
return 1;
|
/* Constants and stack slots never overlap. */
|
/* Constants and stack slots never overlap. */
|
if (CONSTANT_P (xdata.base)
|
if (CONSTANT_P (xdata.base)
|
&& (ydata.base == frame_pointer_rtx
|
&& (ydata.base == frame_pointer_rtx
|
|| ydata.base == hard_frame_pointer_rtx
|
|| ydata.base == hard_frame_pointer_rtx
|
|| ydata.base == stack_pointer_rtx))
|
|| ydata.base == stack_pointer_rtx))
|
return 1;
|
return 1;
|
if (CONSTANT_P (ydata.base)
|
if (CONSTANT_P (ydata.base)
|
&& (xdata.base == frame_pointer_rtx
|
&& (xdata.base == frame_pointer_rtx
|
|| xdata.base == hard_frame_pointer_rtx
|
|| xdata.base == hard_frame_pointer_rtx
|
|| xdata.base == stack_pointer_rtx))
|
|| xdata.base == stack_pointer_rtx))
|
return 1;
|
return 1;
|
/* If either base is variable, we don't know anything. */
|
/* If either base is variable, we don't know anything. */
|
return 0;
|
return 0;
|
}
|
}
|
|
|
return (xdata.start >= ydata.end || ydata.start >= xdata.end);
|
return (xdata.start >= ydata.end || ydata.start >= xdata.end);
|
}
|
}
|
|
|
/* Similar, but calls decompose. */
|
/* Similar, but calls decompose. */
|
|
|
int
|
int
|
safe_from_earlyclobber (rtx op, rtx clobber)
|
safe_from_earlyclobber (rtx op, rtx clobber)
|
{
|
{
|
struct decomposition early_data;
|
struct decomposition early_data;
|
|
|
early_data = decompose (clobber);
|
early_data = decompose (clobber);
|
return immune_p (op, clobber, early_data);
|
return immune_p (op, clobber, early_data);
|
}
|
}
|
|
|
/* Main entry point of this file: search the body of INSN
|
/* Main entry point of this file: search the body of INSN
|
for values that need reloading and record them with push_reload.
|
for values that need reloading and record them with push_reload.
|
REPLACE nonzero means record also where the values occur
|
REPLACE nonzero means record also where the values occur
|
so that subst_reloads can be used.
|
so that subst_reloads can be used.
|
|
|
IND_LEVELS says how many levels of indirection are supported by this
|
IND_LEVELS says how many levels of indirection are supported by this
|
machine; a value of zero means that a memory reference is not a valid
|
machine; a value of zero means that a memory reference is not a valid
|
memory address.
|
memory address.
|
|
|
LIVE_KNOWN says we have valid information about which hard
|
LIVE_KNOWN says we have valid information about which hard
|
regs are live at each point in the program; this is true when
|
regs are live at each point in the program; this is true when
|
we are called from global_alloc but false when stupid register
|
we are called from global_alloc but false when stupid register
|
allocation has been done.
|
allocation has been done.
|
|
|
RELOAD_REG_P if nonzero is a vector indexed by hard reg number
|
RELOAD_REG_P if nonzero is a vector indexed by hard reg number
|
which is nonnegative if the reg has been commandeered for reloading into.
|
which is nonnegative if the reg has been commandeered for reloading into.
|
It is copied into STATIC_RELOAD_REG_P and referenced from there
|
It is copied into STATIC_RELOAD_REG_P and referenced from there
|
by various subroutines.
|
by various subroutines.
|
|
|
Return TRUE if some operands need to be changed, because of swapping
|
Return TRUE if some operands need to be changed, because of swapping
|
commutative operands, reg_equiv_address substitution, or whatever. */
|
commutative operands, reg_equiv_address substitution, or whatever. */
|
|
|
int
|
int
|
find_reloads (rtx insn, int replace, int ind_levels, int live_known,
|
find_reloads (rtx insn, int replace, int ind_levels, int live_known,
|
short *reload_reg_p)
|
short *reload_reg_p)
|
{
|
{
|
int insn_code_number;
|
int insn_code_number;
|
int i, j;
|
int i, j;
|
int noperands;
|
int noperands;
|
/* These start out as the constraints for the insn
|
/* These start out as the constraints for the insn
|
and they are chewed up as we consider alternatives. */
|
and they are chewed up as we consider alternatives. */
|
char *constraints[MAX_RECOG_OPERANDS];
|
char *constraints[MAX_RECOG_OPERANDS];
|
/* These are the preferred classes for an operand, or NO_REGS if it isn't
|
/* These are the preferred classes for an operand, or NO_REGS if it isn't
|
a register. */
|
a register. */
|
enum reg_class preferred_class[MAX_RECOG_OPERANDS];
|
enum reg_class preferred_class[MAX_RECOG_OPERANDS];
|
char pref_or_nothing[MAX_RECOG_OPERANDS];
|
char pref_or_nothing[MAX_RECOG_OPERANDS];
|
/* Nonzero for a MEM operand whose entire address needs a reload.
|
/* Nonzero for a MEM operand whose entire address needs a reload.
|
May be -1 to indicate the entire address may or may not need a reload. */
|
May be -1 to indicate the entire address may or may not need a reload. */
|
int address_reloaded[MAX_RECOG_OPERANDS];
|
int address_reloaded[MAX_RECOG_OPERANDS];
|
/* Nonzero for an address operand that needs to be completely reloaded.
|
/* Nonzero for an address operand that needs to be completely reloaded.
|
May be -1 to indicate the entire operand may or may not need a reload. */
|
May be -1 to indicate the entire operand may or may not need a reload. */
|
int address_operand_reloaded[MAX_RECOG_OPERANDS];
|
int address_operand_reloaded[MAX_RECOG_OPERANDS];
|
/* Value of enum reload_type to use for operand. */
|
/* Value of enum reload_type to use for operand. */
|
enum reload_type operand_type[MAX_RECOG_OPERANDS];
|
enum reload_type operand_type[MAX_RECOG_OPERANDS];
|
/* Value of enum reload_type to use within address of operand. */
|
/* Value of enum reload_type to use within address of operand. */
|
enum reload_type address_type[MAX_RECOG_OPERANDS];
|
enum reload_type address_type[MAX_RECOG_OPERANDS];
|
/* Save the usage of each operand. */
|
/* Save the usage of each operand. */
|
enum reload_usage { RELOAD_READ, RELOAD_READ_WRITE, RELOAD_WRITE } modified[MAX_RECOG_OPERANDS];
|
enum reload_usage { RELOAD_READ, RELOAD_READ_WRITE, RELOAD_WRITE } modified[MAX_RECOG_OPERANDS];
|
int no_input_reloads = 0, no_output_reloads = 0;
|
int no_input_reloads = 0, no_output_reloads = 0;
|
int n_alternatives;
|
int n_alternatives;
|
int this_alternative[MAX_RECOG_OPERANDS];
|
int this_alternative[MAX_RECOG_OPERANDS];
|
char this_alternative_match_win[MAX_RECOG_OPERANDS];
|
char this_alternative_match_win[MAX_RECOG_OPERANDS];
|
char this_alternative_win[MAX_RECOG_OPERANDS];
|
char this_alternative_win[MAX_RECOG_OPERANDS];
|
char this_alternative_offmemok[MAX_RECOG_OPERANDS];
|
char this_alternative_offmemok[MAX_RECOG_OPERANDS];
|
char this_alternative_earlyclobber[MAX_RECOG_OPERANDS];
|
char this_alternative_earlyclobber[MAX_RECOG_OPERANDS];
|
int this_alternative_matches[MAX_RECOG_OPERANDS];
|
int this_alternative_matches[MAX_RECOG_OPERANDS];
|
int swapped;
|
int swapped;
|
int goal_alternative[MAX_RECOG_OPERANDS];
|
int goal_alternative[MAX_RECOG_OPERANDS];
|
int this_alternative_number;
|
int this_alternative_number;
|
int goal_alternative_number = 0;
|
int goal_alternative_number = 0;
|
int operand_reloadnum[MAX_RECOG_OPERANDS];
|
int operand_reloadnum[MAX_RECOG_OPERANDS];
|
int goal_alternative_matches[MAX_RECOG_OPERANDS];
|
int goal_alternative_matches[MAX_RECOG_OPERANDS];
|
int goal_alternative_matched[MAX_RECOG_OPERANDS];
|
int goal_alternative_matched[MAX_RECOG_OPERANDS];
|
char goal_alternative_match_win[MAX_RECOG_OPERANDS];
|
char goal_alternative_match_win[MAX_RECOG_OPERANDS];
|
char goal_alternative_win[MAX_RECOG_OPERANDS];
|
char goal_alternative_win[MAX_RECOG_OPERANDS];
|
char goal_alternative_offmemok[MAX_RECOG_OPERANDS];
|
char goal_alternative_offmemok[MAX_RECOG_OPERANDS];
|
char goal_alternative_earlyclobber[MAX_RECOG_OPERANDS];
|
char goal_alternative_earlyclobber[MAX_RECOG_OPERANDS];
|
int goal_alternative_swapped;
|
int goal_alternative_swapped;
|
int best;
|
int best;
|
int commutative;
|
int commutative;
|
char operands_match[MAX_RECOG_OPERANDS][MAX_RECOG_OPERANDS];
|
char operands_match[MAX_RECOG_OPERANDS][MAX_RECOG_OPERANDS];
|
rtx substed_operand[MAX_RECOG_OPERANDS];
|
rtx substed_operand[MAX_RECOG_OPERANDS];
|
rtx body = PATTERN (insn);
|
rtx body = PATTERN (insn);
|
rtx set = single_set (insn);
|
rtx set = single_set (insn);
|
int goal_earlyclobber = 0, this_earlyclobber;
|
int goal_earlyclobber = 0, this_earlyclobber;
|
enum machine_mode operand_mode[MAX_RECOG_OPERANDS];
|
enum machine_mode operand_mode[MAX_RECOG_OPERANDS];
|
int retval = 0;
|
int retval = 0;
|
|
|
this_insn = insn;
|
this_insn = insn;
|
n_reloads = 0;
|
n_reloads = 0;
|
n_replacements = 0;
|
n_replacements = 0;
|
n_earlyclobbers = 0;
|
n_earlyclobbers = 0;
|
replace_reloads = replace;
|
replace_reloads = replace;
|
hard_regs_live_known = live_known;
|
hard_regs_live_known = live_known;
|
static_reload_reg_p = reload_reg_p;
|
static_reload_reg_p = reload_reg_p;
|
|
|
/* JUMP_INSNs and CALL_INSNs are not allowed to have any output reloads;
|
/* JUMP_INSNs and CALL_INSNs are not allowed to have any output reloads;
|
neither are insns that SET cc0. Insns that use CC0 are not allowed
|
neither are insns that SET cc0. Insns that use CC0 are not allowed
|
to have any input reloads. */
|
to have any input reloads. */
|
if (JUMP_P (insn) || CALL_P (insn))
|
if (JUMP_P (insn) || CALL_P (insn))
|
no_output_reloads = 1;
|
no_output_reloads = 1;
|
|
|
#ifdef HAVE_cc0
|
#ifdef HAVE_cc0
|
if (reg_referenced_p (cc0_rtx, PATTERN (insn)))
|
if (reg_referenced_p (cc0_rtx, PATTERN (insn)))
|
no_input_reloads = 1;
|
no_input_reloads = 1;
|
if (reg_set_p (cc0_rtx, PATTERN (insn)))
|
if (reg_set_p (cc0_rtx, PATTERN (insn)))
|
no_output_reloads = 1;
|
no_output_reloads = 1;
|
#endif
|
#endif
|
|
|
#ifdef SECONDARY_MEMORY_NEEDED
|
#ifdef SECONDARY_MEMORY_NEEDED
|
/* The eliminated forms of any secondary memory locations are per-insn, so
|
/* The eliminated forms of any secondary memory locations are per-insn, so
|
clear them out here. */
|
clear them out here. */
|
|
|
if (secondary_memlocs_elim_used)
|
if (secondary_memlocs_elim_used)
|
{
|
{
|
memset (secondary_memlocs_elim, 0,
|
memset (secondary_memlocs_elim, 0,
|
sizeof (secondary_memlocs_elim[0]) * secondary_memlocs_elim_used);
|
sizeof (secondary_memlocs_elim[0]) * secondary_memlocs_elim_used);
|
secondary_memlocs_elim_used = 0;
|
secondary_memlocs_elim_used = 0;
|
}
|
}
|
#endif
|
#endif
|
|
|
/* Dispose quickly of (set (reg..) (reg..)) if both have hard regs and it
|
/* Dispose quickly of (set (reg..) (reg..)) if both have hard regs and it
|
is cheap to move between them. If it is not, there may not be an insn
|
is cheap to move between them. If it is not, there may not be an insn
|
to do the copy, so we may need a reload. */
|
to do the copy, so we may need a reload. */
|
if (GET_CODE (body) == SET
|
if (GET_CODE (body) == SET
|
&& REG_P (SET_DEST (body))
|
&& REG_P (SET_DEST (body))
|
&& REGNO (SET_DEST (body)) < FIRST_PSEUDO_REGISTER
|
&& REGNO (SET_DEST (body)) < FIRST_PSEUDO_REGISTER
|
&& REG_P (SET_SRC (body))
|
&& REG_P (SET_SRC (body))
|
&& REGNO (SET_SRC (body)) < FIRST_PSEUDO_REGISTER
|
&& REGNO (SET_SRC (body)) < FIRST_PSEUDO_REGISTER
|
&& REGISTER_MOVE_COST (GET_MODE (SET_SRC (body)),
|
&& REGISTER_MOVE_COST (GET_MODE (SET_SRC (body)),
|
REGNO_REG_CLASS (REGNO (SET_SRC (body))),
|
REGNO_REG_CLASS (REGNO (SET_SRC (body))),
|
REGNO_REG_CLASS (REGNO (SET_DEST (body)))) == 2)
|
REGNO_REG_CLASS (REGNO (SET_DEST (body)))) == 2)
|
return 0;
|
return 0;
|
|
|
extract_insn (insn);
|
extract_insn (insn);
|
|
|
noperands = reload_n_operands = recog_data.n_operands;
|
noperands = reload_n_operands = recog_data.n_operands;
|
n_alternatives = recog_data.n_alternatives;
|
n_alternatives = recog_data.n_alternatives;
|
|
|
/* Just return "no reloads" if insn has no operands with constraints. */
|
/* Just return "no reloads" if insn has no operands with constraints. */
|
if (noperands == 0 || n_alternatives == 0)
|
if (noperands == 0 || n_alternatives == 0)
|
return 0;
|
return 0;
|
|
|
insn_code_number = INSN_CODE (insn);
|
insn_code_number = INSN_CODE (insn);
|
this_insn_is_asm = insn_code_number < 0;
|
this_insn_is_asm = insn_code_number < 0;
|
|
|
memcpy (operand_mode, recog_data.operand_mode,
|
memcpy (operand_mode, recog_data.operand_mode,
|
noperands * sizeof (enum machine_mode));
|
noperands * sizeof (enum machine_mode));
|
memcpy (constraints, recog_data.constraints, noperands * sizeof (char *));
|
memcpy (constraints, recog_data.constraints, noperands * sizeof (char *));
|
|
|
commutative = -1;
|
commutative = -1;
|
|
|
/* If we will need to know, later, whether some pair of operands
|
/* If we will need to know, later, whether some pair of operands
|
are the same, we must compare them now and save the result.
|
are the same, we must compare them now and save the result.
|
Reloading the base and index registers will clobber them
|
Reloading the base and index registers will clobber them
|
and afterward they will fail to match. */
|
and afterward they will fail to match. */
|
|
|
for (i = 0; i < noperands; i++)
|
for (i = 0; i < noperands; i++)
|
{
|
{
|
char *p;
|
char *p;
|
int c;
|
int c;
|
|
|
substed_operand[i] = recog_data.operand[i];
|
substed_operand[i] = recog_data.operand[i];
|
p = constraints[i];
|
p = constraints[i];
|
|
|
modified[i] = RELOAD_READ;
|
modified[i] = RELOAD_READ;
|
|
|
/* Scan this operand's constraint to see if it is an output operand,
|
/* Scan this operand's constraint to see if it is an output operand,
|
an in-out operand, is commutative, or should match another. */
|
an in-out operand, is commutative, or should match another. */
|
|
|
while ((c = *p))
|
while ((c = *p))
|
{
|
{
|
p += CONSTRAINT_LEN (c, p);
|
p += CONSTRAINT_LEN (c, p);
|
switch (c)
|
switch (c)
|
{
|
{
|
case '=':
|
case '=':
|
modified[i] = RELOAD_WRITE;
|
modified[i] = RELOAD_WRITE;
|
break;
|
break;
|
case '+':
|
case '+':
|
modified[i] = RELOAD_READ_WRITE;
|
modified[i] = RELOAD_READ_WRITE;
|
break;
|
break;
|
case '%':
|
case '%':
|
{
|
{
|
/* The last operand should not be marked commutative. */
|
/* The last operand should not be marked commutative. */
|
gcc_assert (i != noperands - 1);
|
gcc_assert (i != noperands - 1);
|
|
|
/* We currently only support one commutative pair of
|
/* We currently only support one commutative pair of
|
operands. Some existing asm code currently uses more
|
operands. Some existing asm code currently uses more
|
than one pair. Previously, that would usually work,
|
than one pair. Previously, that would usually work,
|
but sometimes it would crash the compiler. We
|
but sometimes it would crash the compiler. We
|
continue supporting that case as well as we can by
|
continue supporting that case as well as we can by
|
silently ignoring all but the first pair. In the
|
silently ignoring all but the first pair. In the
|
future we may handle it correctly. */
|
future we may handle it correctly. */
|
if (commutative < 0)
|
if (commutative < 0)
|
commutative = i;
|
commutative = i;
|
else
|
else
|
gcc_assert (this_insn_is_asm);
|
gcc_assert (this_insn_is_asm);
|
}
|
}
|
break;
|
break;
|
/* Use of ISDIGIT is tempting here, but it may get expensive because
|
/* Use of ISDIGIT is tempting here, but it may get expensive because
|
of locale support we don't want. */
|
of locale support we don't want. */
|
case '0': case '1': case '2': case '3': case '4':
|
case '0': case '1': case '2': case '3': case '4':
|
case '5': case '6': case '7': case '8': case '9':
|
case '5': case '6': case '7': case '8': case '9':
|
{
|
{
|
c = strtoul (p - 1, &p, 10);
|
c = strtoul (p - 1, &p, 10);
|
|
|
operands_match[c][i]
|
operands_match[c][i]
|
= operands_match_p (recog_data.operand[c],
|
= operands_match_p (recog_data.operand[c],
|
recog_data.operand[i]);
|
recog_data.operand[i]);
|
|
|
/* An operand may not match itself. */
|
/* An operand may not match itself. */
|
gcc_assert (c != i);
|
gcc_assert (c != i);
|
|
|
/* If C can be commuted with C+1, and C might need to match I,
|
/* If C can be commuted with C+1, and C might need to match I,
|
then C+1 might also need to match I. */
|
then C+1 might also need to match I. */
|
if (commutative >= 0)
|
if (commutative >= 0)
|
{
|
{
|
if (c == commutative || c == commutative + 1)
|
if (c == commutative || c == commutative + 1)
|
{
|
{
|
int other = c + (c == commutative ? 1 : -1);
|
int other = c + (c == commutative ? 1 : -1);
|
operands_match[other][i]
|
operands_match[other][i]
|
= operands_match_p (recog_data.operand[other],
|
= operands_match_p (recog_data.operand[other],
|
recog_data.operand[i]);
|
recog_data.operand[i]);
|
}
|
}
|
if (i == commutative || i == commutative + 1)
|
if (i == commutative || i == commutative + 1)
|
{
|
{
|
int other = i + (i == commutative ? 1 : -1);
|
int other = i + (i == commutative ? 1 : -1);
|
operands_match[c][other]
|
operands_match[c][other]
|
= operands_match_p (recog_data.operand[c],
|
= operands_match_p (recog_data.operand[c],
|
recog_data.operand[other]);
|
recog_data.operand[other]);
|
}
|
}
|
/* Note that C is supposed to be less than I.
|
/* Note that C is supposed to be less than I.
|
No need to consider altering both C and I because in
|
No need to consider altering both C and I because in
|
that case we would alter one into the other. */
|
that case we would alter one into the other. */
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Examine each operand that is a memory reference or memory address
|
/* Examine each operand that is a memory reference or memory address
|
and reload parts of the addresses into index registers.
|
and reload parts of the addresses into index registers.
|
Also here any references to pseudo regs that didn't get hard regs
|
Also here any references to pseudo regs that didn't get hard regs
|
but are equivalent to constants get replaced in the insn itself
|
but are equivalent to constants get replaced in the insn itself
|
with those constants. Nobody will ever see them again.
|
with those constants. Nobody will ever see them again.
|
|
|
Finally, set up the preferred classes of each operand. */
|
Finally, set up the preferred classes of each operand. */
|
|
|
for (i = 0; i < noperands; i++)
|
for (i = 0; i < noperands; i++)
|
{
|
{
|
RTX_CODE code = GET_CODE (recog_data.operand[i]);
|
RTX_CODE code = GET_CODE (recog_data.operand[i]);
|
|
|
address_reloaded[i] = 0;
|
address_reloaded[i] = 0;
|
address_operand_reloaded[i] = 0;
|
address_operand_reloaded[i] = 0;
|
operand_type[i] = (modified[i] == RELOAD_READ ? RELOAD_FOR_INPUT
|
operand_type[i] = (modified[i] == RELOAD_READ ? RELOAD_FOR_INPUT
|
: modified[i] == RELOAD_WRITE ? RELOAD_FOR_OUTPUT
|
: modified[i] == RELOAD_WRITE ? RELOAD_FOR_OUTPUT
|
: RELOAD_OTHER);
|
: RELOAD_OTHER);
|
address_type[i]
|
address_type[i]
|
= (modified[i] == RELOAD_READ ? RELOAD_FOR_INPUT_ADDRESS
|
= (modified[i] == RELOAD_READ ? RELOAD_FOR_INPUT_ADDRESS
|
: modified[i] == RELOAD_WRITE ? RELOAD_FOR_OUTPUT_ADDRESS
|
: modified[i] == RELOAD_WRITE ? RELOAD_FOR_OUTPUT_ADDRESS
|
: RELOAD_OTHER);
|
: RELOAD_OTHER);
|
|
|
if (*constraints[i] == 0)
|
if (*constraints[i] == 0)
|
/* Ignore things like match_operator operands. */
|
/* Ignore things like match_operator operands. */
|
;
|
;
|
else if (constraints[i][0] == 'p'
|
else if (constraints[i][0] == 'p'
|
|| EXTRA_ADDRESS_CONSTRAINT (constraints[i][0], constraints[i]))
|
|| EXTRA_ADDRESS_CONSTRAINT (constraints[i][0], constraints[i]))
|
{
|
{
|
address_operand_reloaded[i]
|
address_operand_reloaded[i]
|
= find_reloads_address (recog_data.operand_mode[i], (rtx*) 0,
|
= find_reloads_address (recog_data.operand_mode[i], (rtx*) 0,
|
recog_data.operand[i],
|
recog_data.operand[i],
|
recog_data.operand_loc[i],
|
recog_data.operand_loc[i],
|
i, operand_type[i], ind_levels, insn);
|
i, operand_type[i], ind_levels, insn);
|
|
|
/* If we now have a simple operand where we used to have a
|
/* If we now have a simple operand where we used to have a
|
PLUS or MULT, re-recognize and try again. */
|
PLUS or MULT, re-recognize and try again. */
|
if ((OBJECT_P (*recog_data.operand_loc[i])
|
if ((OBJECT_P (*recog_data.operand_loc[i])
|
|| GET_CODE (*recog_data.operand_loc[i]) == SUBREG)
|
|| GET_CODE (*recog_data.operand_loc[i]) == SUBREG)
|
&& (GET_CODE (recog_data.operand[i]) == MULT
|
&& (GET_CODE (recog_data.operand[i]) == MULT
|
|| GET_CODE (recog_data.operand[i]) == PLUS))
|
|| GET_CODE (recog_data.operand[i]) == PLUS))
|
{
|
{
|
INSN_CODE (insn) = -1;
|
INSN_CODE (insn) = -1;
|
retval = find_reloads (insn, replace, ind_levels, live_known,
|
retval = find_reloads (insn, replace, ind_levels, live_known,
|
reload_reg_p);
|
reload_reg_p);
|
return retval;
|
return retval;
|
}
|
}
|
|
|
recog_data.operand[i] = *recog_data.operand_loc[i];
|
recog_data.operand[i] = *recog_data.operand_loc[i];
|
substed_operand[i] = recog_data.operand[i];
|
substed_operand[i] = recog_data.operand[i];
|
|
|
/* Address operands are reloaded in their existing mode,
|
/* Address operands are reloaded in their existing mode,
|
no matter what is specified in the machine description. */
|
no matter what is specified in the machine description. */
|
operand_mode[i] = GET_MODE (recog_data.operand[i]);
|
operand_mode[i] = GET_MODE (recog_data.operand[i]);
|
}
|
}
|
else if (code == MEM)
|
else if (code == MEM)
|
{
|
{
|
address_reloaded[i]
|
address_reloaded[i]
|
= find_reloads_address (GET_MODE (recog_data.operand[i]),
|
= find_reloads_address (GET_MODE (recog_data.operand[i]),
|
recog_data.operand_loc[i],
|
recog_data.operand_loc[i],
|
XEXP (recog_data.operand[i], 0),
|
XEXP (recog_data.operand[i], 0),
|
&XEXP (recog_data.operand[i], 0),
|
&XEXP (recog_data.operand[i], 0),
|
i, address_type[i], ind_levels, insn);
|
i, address_type[i], ind_levels, insn);
|
recog_data.operand[i] = *recog_data.operand_loc[i];
|
recog_data.operand[i] = *recog_data.operand_loc[i];
|
substed_operand[i] = recog_data.operand[i];
|
substed_operand[i] = recog_data.operand[i];
|
}
|
}
|
else if (code == SUBREG)
|
else if (code == SUBREG)
|
{
|
{
|
rtx reg = SUBREG_REG (recog_data.operand[i]);
|
rtx reg = SUBREG_REG (recog_data.operand[i]);
|
rtx op
|
rtx op
|
= find_reloads_toplev (recog_data.operand[i], i, address_type[i],
|
= find_reloads_toplev (recog_data.operand[i], i, address_type[i],
|
ind_levels,
|
ind_levels,
|
set != 0
|
set != 0
|
&& &SET_DEST (set) == recog_data.operand_loc[i],
|
&& &SET_DEST (set) == recog_data.operand_loc[i],
|
insn,
|
insn,
|
&address_reloaded[i]);
|
&address_reloaded[i]);
|
|
|
/* If we made a MEM to load (a part of) the stackslot of a pseudo
|
/* If we made a MEM to load (a part of) the stackslot of a pseudo
|
that didn't get a hard register, emit a USE with a REG_EQUAL
|
that didn't get a hard register, emit a USE with a REG_EQUAL
|
note in front so that we might inherit a previous, possibly
|
note in front so that we might inherit a previous, possibly
|
wider reload. */
|
wider reload. */
|
|
|
if (replace
|
if (replace
|
&& MEM_P (op)
|
&& MEM_P (op)
|
&& REG_P (reg)
|
&& REG_P (reg)
|
&& (GET_MODE_SIZE (GET_MODE (reg))
|
&& (GET_MODE_SIZE (GET_MODE (reg))
|
>= GET_MODE_SIZE (GET_MODE (op))))
|
>= GET_MODE_SIZE (GET_MODE (op))))
|
set_unique_reg_note (emit_insn_before (gen_rtx_USE (VOIDmode, reg),
|
set_unique_reg_note (emit_insn_before (gen_rtx_USE (VOIDmode, reg),
|
insn),
|
insn),
|
REG_EQUAL, reg_equiv_memory_loc[REGNO (reg)]);
|
REG_EQUAL, reg_equiv_memory_loc[REGNO (reg)]);
|
|
|
substed_operand[i] = recog_data.operand[i] = op;
|
substed_operand[i] = recog_data.operand[i] = op;
|
}
|
}
|
else if (code == PLUS || GET_RTX_CLASS (code) == RTX_UNARY)
|
else if (code == PLUS || GET_RTX_CLASS (code) == RTX_UNARY)
|
/* We can get a PLUS as an "operand" as a result of register
|
/* We can get a PLUS as an "operand" as a result of register
|
elimination. See eliminate_regs and gen_reload. We handle
|
elimination. See eliminate_regs and gen_reload. We handle
|
a unary operator by reloading the operand. */
|
a unary operator by reloading the operand. */
|
substed_operand[i] = recog_data.operand[i]
|
substed_operand[i] = recog_data.operand[i]
|
= find_reloads_toplev (recog_data.operand[i], i, address_type[i],
|
= find_reloads_toplev (recog_data.operand[i], i, address_type[i],
|
ind_levels, 0, insn,
|
ind_levels, 0, insn,
|
&address_reloaded[i]);
|
&address_reloaded[i]);
|
else if (code == REG)
|
else if (code == REG)
|
{
|
{
|
/* This is equivalent to calling find_reloads_toplev.
|
/* This is equivalent to calling find_reloads_toplev.
|
The code is duplicated for speed.
|
The code is duplicated for speed.
|
When we find a pseudo always equivalent to a constant,
|
When we find a pseudo always equivalent to a constant,
|
we replace it by the constant. We must be sure, however,
|
we replace it by the constant. We must be sure, however,
|
that we don't try to replace it in the insn in which it
|
that we don't try to replace it in the insn in which it
|
is being set. */
|
is being set. */
|
int regno = REGNO (recog_data.operand[i]);
|
int regno = REGNO (recog_data.operand[i]);
|
if (reg_equiv_constant[regno] != 0
|
if (reg_equiv_constant[regno] != 0
|
&& (set == 0 || &SET_DEST (set) != recog_data.operand_loc[i]))
|
&& (set == 0 || &SET_DEST (set) != recog_data.operand_loc[i]))
|
{
|
{
|
/* Record the existing mode so that the check if constants are
|
/* Record the existing mode so that the check if constants are
|
allowed will work when operand_mode isn't specified. */
|
allowed will work when operand_mode isn't specified. */
|
|
|
if (operand_mode[i] == VOIDmode)
|
if (operand_mode[i] == VOIDmode)
|
operand_mode[i] = GET_MODE (recog_data.operand[i]);
|
operand_mode[i] = GET_MODE (recog_data.operand[i]);
|
|
|
substed_operand[i] = recog_data.operand[i]
|
substed_operand[i] = recog_data.operand[i]
|
= reg_equiv_constant[regno];
|
= reg_equiv_constant[regno];
|
}
|
}
|
if (reg_equiv_memory_loc[regno] != 0
|
if (reg_equiv_memory_loc[regno] != 0
|
&& (reg_equiv_address[regno] != 0 || num_not_at_initial_offset))
|
&& (reg_equiv_address[regno] != 0 || num_not_at_initial_offset))
|
/* We need not give a valid is_set_dest argument since the case
|
/* We need not give a valid is_set_dest argument since the case
|
of a constant equivalence was checked above. */
|
of a constant equivalence was checked above. */
|
substed_operand[i] = recog_data.operand[i]
|
substed_operand[i] = recog_data.operand[i]
|
= find_reloads_toplev (recog_data.operand[i], i, address_type[i],
|
= find_reloads_toplev (recog_data.operand[i], i, address_type[i],
|
ind_levels, 0, insn,
|
ind_levels, 0, insn,
|
&address_reloaded[i]);
|
&address_reloaded[i]);
|
}
|
}
|
/* If the operand is still a register (we didn't replace it with an
|
/* If the operand is still a register (we didn't replace it with an
|
equivalent), get the preferred class to reload it into. */
|
equivalent), get the preferred class to reload it into. */
|
code = GET_CODE (recog_data.operand[i]);
|
code = GET_CODE (recog_data.operand[i]);
|
preferred_class[i]
|
preferred_class[i]
|
= ((code == REG && REGNO (recog_data.operand[i])
|
= ((code == REG && REGNO (recog_data.operand[i])
|
>= FIRST_PSEUDO_REGISTER)
|
>= FIRST_PSEUDO_REGISTER)
|
? reg_preferred_class (REGNO (recog_data.operand[i]))
|
? reg_preferred_class (REGNO (recog_data.operand[i]))
|
: NO_REGS);
|
: NO_REGS);
|
pref_or_nothing[i]
|
pref_or_nothing[i]
|
= (code == REG
|
= (code == REG
|
&& REGNO (recog_data.operand[i]) >= FIRST_PSEUDO_REGISTER
|
&& REGNO (recog_data.operand[i]) >= FIRST_PSEUDO_REGISTER
|
&& reg_alternate_class (REGNO (recog_data.operand[i])) == NO_REGS);
|
&& reg_alternate_class (REGNO (recog_data.operand[i])) == NO_REGS);
|
}
|
}
|
|
|
/* If this is simply a copy from operand 1 to operand 0, merge the
|
/* If this is simply a copy from operand 1 to operand 0, merge the
|
preferred classes for the operands. */
|
preferred classes for the operands. */
|
if (set != 0 && noperands >= 2 && recog_data.operand[0] == SET_DEST (set)
|
if (set != 0 && noperands >= 2 && recog_data.operand[0] == SET_DEST (set)
|
&& recog_data.operand[1] == SET_SRC (set))
|
&& recog_data.operand[1] == SET_SRC (set))
|
{
|
{
|
preferred_class[0] = preferred_class[1]
|
preferred_class[0] = preferred_class[1]
|
= reg_class_subunion[(int) preferred_class[0]][(int) preferred_class[1]];
|
= reg_class_subunion[(int) preferred_class[0]][(int) preferred_class[1]];
|
pref_or_nothing[0] |= pref_or_nothing[1];
|
pref_or_nothing[0] |= pref_or_nothing[1];
|
pref_or_nothing[1] |= pref_or_nothing[0];
|
pref_or_nothing[1] |= pref_or_nothing[0];
|
}
|
}
|
|
|
/* Now see what we need for pseudo-regs that didn't get hard regs
|
/* Now see what we need for pseudo-regs that didn't get hard regs
|
or got the wrong kind of hard reg. For this, we must consider
|
or got the wrong kind of hard reg. For this, we must consider
|
all the operands together against the register constraints. */
|
all the operands together against the register constraints. */
|
|
|
best = MAX_RECOG_OPERANDS * 2 + 600;
|
best = MAX_RECOG_OPERANDS * 2 + 600;
|
|
|
swapped = 0;
|
swapped = 0;
|
goal_alternative_swapped = 0;
|
goal_alternative_swapped = 0;
|
try_swapped:
|
try_swapped:
|
|
|
/* The constraints are made of several alternatives.
|
/* The constraints are made of several alternatives.
|
Each operand's constraint looks like foo,bar,... with commas
|
Each operand's constraint looks like foo,bar,... with commas
|
separating the alternatives. The first alternatives for all
|
separating the alternatives. The first alternatives for all
|
operands go together, the second alternatives go together, etc.
|
operands go together, the second alternatives go together, etc.
|
|
|
First loop over alternatives. */
|
First loop over alternatives. */
|
|
|
for (this_alternative_number = 0;
|
for (this_alternative_number = 0;
|
this_alternative_number < n_alternatives;
|
this_alternative_number < n_alternatives;
|
this_alternative_number++)
|
this_alternative_number++)
|
{
|
{
|
/* Loop over operands for one constraint alternative. */
|
/* Loop over operands for one constraint alternative. */
|
/* LOSERS counts those that don't fit this alternative
|
/* LOSERS counts those that don't fit this alternative
|
and would require loading. */
|
and would require loading. */
|
int losers = 0;
|
int losers = 0;
|
/* BAD is set to 1 if it some operand can't fit this alternative
|
/* BAD is set to 1 if it some operand can't fit this alternative
|
even after reloading. */
|
even after reloading. */
|
int bad = 0;
|
int bad = 0;
|
/* REJECT is a count of how undesirable this alternative says it is
|
/* REJECT is a count of how undesirable this alternative says it is
|
if any reloading is required. If the alternative matches exactly
|
if any reloading is required. If the alternative matches exactly
|
then REJECT is ignored, but otherwise it gets this much
|
then REJECT is ignored, but otherwise it gets this much
|
counted against it in addition to the reloading needed. Each
|
counted against it in addition to the reloading needed. Each
|
? counts three times here since we want the disparaging caused by
|
? counts three times here since we want the disparaging caused by
|
a bad register class to only count 1/3 as much. */
|
a bad register class to only count 1/3 as much. */
|
int reject = 0;
|
int reject = 0;
|
|
|
this_earlyclobber = 0;
|
this_earlyclobber = 0;
|
|
|
for (i = 0; i < noperands; i++)
|
for (i = 0; i < noperands; i++)
|
{
|
{
|
char *p = constraints[i];
|
char *p = constraints[i];
|
char *end;
|
char *end;
|
int len;
|
int len;
|
int win = 0;
|
int win = 0;
|
int did_match = 0;
|
int did_match = 0;
|
/* 0 => this operand can be reloaded somehow for this alternative. */
|
/* 0 => this operand can be reloaded somehow for this alternative. */
|
int badop = 1;
|
int badop = 1;
|
/* 0 => this operand can be reloaded if the alternative allows regs. */
|
/* 0 => this operand can be reloaded if the alternative allows regs. */
|
int winreg = 0;
|
int winreg = 0;
|
int c;
|
int c;
|
int m;
|
int m;
|
rtx operand = recog_data.operand[i];
|
rtx operand = recog_data.operand[i];
|
int offset = 0;
|
int offset = 0;
|
/* Nonzero means this is a MEM that must be reloaded into a reg
|
/* Nonzero means this is a MEM that must be reloaded into a reg
|
regardless of what the constraint says. */
|
regardless of what the constraint says. */
|
int force_reload = 0;
|
int force_reload = 0;
|
int offmemok = 0;
|
int offmemok = 0;
|
/* Nonzero if a constant forced into memory would be OK for this
|
/* Nonzero if a constant forced into memory would be OK for this
|
operand. */
|
operand. */
|
int constmemok = 0;
|
int constmemok = 0;
|
int earlyclobber = 0;
|
int earlyclobber = 0;
|
|
|
/* If the predicate accepts a unary operator, it means that
|
/* If the predicate accepts a unary operator, it means that
|
we need to reload the operand, but do not do this for
|
we need to reload the operand, but do not do this for
|
match_operator and friends. */
|
match_operator and friends. */
|
if (UNARY_P (operand) && *p != 0)
|
if (UNARY_P (operand) && *p != 0)
|
operand = XEXP (operand, 0);
|
operand = XEXP (operand, 0);
|
|
|
/* If the operand is a SUBREG, extract
|
/* If the operand is a SUBREG, extract
|
the REG or MEM (or maybe even a constant) within.
|
the REG or MEM (or maybe even a constant) within.
|
(Constants can occur as a result of reg_equiv_constant.) */
|
(Constants can occur as a result of reg_equiv_constant.) */
|
|
|
while (GET_CODE (operand) == SUBREG)
|
while (GET_CODE (operand) == SUBREG)
|
{
|
{
|
/* Offset only matters when operand is a REG and
|
/* Offset only matters when operand is a REG and
|
it is a hard reg. This is because it is passed
|
it is a hard reg. This is because it is passed
|
to reg_fits_class_p if it is a REG and all pseudos
|
to reg_fits_class_p if it is a REG and all pseudos
|
return 0 from that function. */
|
return 0 from that function. */
|
if (REG_P (SUBREG_REG (operand))
|
if (REG_P (SUBREG_REG (operand))
|
&& REGNO (SUBREG_REG (operand)) < FIRST_PSEUDO_REGISTER)
|
&& REGNO (SUBREG_REG (operand)) < FIRST_PSEUDO_REGISTER)
|
{
|
{
|
if (!subreg_offset_representable_p
|
if (!subreg_offset_representable_p
|
(REGNO (SUBREG_REG (operand)),
|
(REGNO (SUBREG_REG (operand)),
|
GET_MODE (SUBREG_REG (operand)),
|
GET_MODE (SUBREG_REG (operand)),
|
SUBREG_BYTE (operand),
|
SUBREG_BYTE (operand),
|
GET_MODE (operand)))
|
GET_MODE (operand)))
|
force_reload = 1;
|
force_reload = 1;
|
offset += subreg_regno_offset (REGNO (SUBREG_REG (operand)),
|
offset += subreg_regno_offset (REGNO (SUBREG_REG (operand)),
|
GET_MODE (SUBREG_REG (operand)),
|
GET_MODE (SUBREG_REG (operand)),
|
SUBREG_BYTE (operand),
|
SUBREG_BYTE (operand),
|
GET_MODE (operand));
|
GET_MODE (operand));
|
}
|
}
|
operand = SUBREG_REG (operand);
|
operand = SUBREG_REG (operand);
|
/* Force reload if this is a constant or PLUS or if there may
|
/* Force reload if this is a constant or PLUS or if there may
|
be a problem accessing OPERAND in the outer mode. */
|
be a problem accessing OPERAND in the outer mode. */
|
if (CONSTANT_P (operand)
|
if (CONSTANT_P (operand)
|
|| GET_CODE (operand) == PLUS
|
|| GET_CODE (operand) == PLUS
|
/* We must force a reload of paradoxical SUBREGs
|
/* We must force a reload of paradoxical SUBREGs
|
of a MEM because the alignment of the inner value
|
of a MEM because the alignment of the inner value
|
may not be enough to do the outer reference. On
|
may not be enough to do the outer reference. On
|
big-endian machines, it may also reference outside
|
big-endian machines, it may also reference outside
|
the object.
|
the object.
|
|
|
On machines that extend byte operations and we have a
|
On machines that extend byte operations and we have a
|
SUBREG where both the inner and outer modes are no wider
|
SUBREG where both the inner and outer modes are no wider
|
than a word and the inner mode is narrower, is integral,
|
than a word and the inner mode is narrower, is integral,
|
and gets extended when loaded from memory, combine.c has
|
and gets extended when loaded from memory, combine.c has
|
made assumptions about the behavior of the machine in such
|
made assumptions about the behavior of the machine in such
|
register access. If the data is, in fact, in memory we
|
register access. If the data is, in fact, in memory we
|
must always load using the size assumed to be in the
|
must always load using the size assumed to be in the
|
register and let the insn do the different-sized
|
register and let the insn do the different-sized
|
accesses.
|
accesses.
|
|
|
This is doubly true if WORD_REGISTER_OPERATIONS. In
|
This is doubly true if WORD_REGISTER_OPERATIONS. In
|
this case eliminate_regs has left non-paradoxical
|
this case eliminate_regs has left non-paradoxical
|
subregs for push_reload to see. Make sure it does
|
subregs for push_reload to see. Make sure it does
|
by forcing the reload.
|
by forcing the reload.
|
|
|
??? When is it right at this stage to have a subreg
|
??? When is it right at this stage to have a subreg
|
of a mem that is _not_ to be handled specially? IMO
|
of a mem that is _not_ to be handled specially? IMO
|
those should have been reduced to just a mem. */
|
those should have been reduced to just a mem. */
|
|| ((MEM_P (operand)
|
|| ((MEM_P (operand)
|
|| (REG_P (operand)
|
|| (REG_P (operand)
|
&& REGNO (operand) >= FIRST_PSEUDO_REGISTER))
|
&& REGNO (operand) >= FIRST_PSEUDO_REGISTER))
|
#ifndef WORD_REGISTER_OPERATIONS
|
#ifndef WORD_REGISTER_OPERATIONS
|
&& (((GET_MODE_BITSIZE (GET_MODE (operand))
|
&& (((GET_MODE_BITSIZE (GET_MODE (operand))
|
< BIGGEST_ALIGNMENT)
|
< BIGGEST_ALIGNMENT)
|
&& (GET_MODE_SIZE (operand_mode[i])
|
&& (GET_MODE_SIZE (operand_mode[i])
|
> GET_MODE_SIZE (GET_MODE (operand))))
|
> GET_MODE_SIZE (GET_MODE (operand))))
|
|| BYTES_BIG_ENDIAN
|
|| BYTES_BIG_ENDIAN
|
#ifdef LOAD_EXTEND_OP
|
#ifdef LOAD_EXTEND_OP
|
|| (GET_MODE_SIZE (operand_mode[i]) <= UNITS_PER_WORD
|
|| (GET_MODE_SIZE (operand_mode[i]) <= UNITS_PER_WORD
|
&& (GET_MODE_SIZE (GET_MODE (operand))
|
&& (GET_MODE_SIZE (GET_MODE (operand))
|
<= UNITS_PER_WORD)
|
<= UNITS_PER_WORD)
|
&& (GET_MODE_SIZE (operand_mode[i])
|
&& (GET_MODE_SIZE (operand_mode[i])
|
> GET_MODE_SIZE (GET_MODE (operand)))
|
> GET_MODE_SIZE (GET_MODE (operand)))
|
&& INTEGRAL_MODE_P (GET_MODE (operand))
|
&& INTEGRAL_MODE_P (GET_MODE (operand))
|
&& LOAD_EXTEND_OP (GET_MODE (operand)) != UNKNOWN)
|
&& LOAD_EXTEND_OP (GET_MODE (operand)) != UNKNOWN)
|
#endif
|
#endif
|
)
|
)
|
#endif
|
#endif
|
)
|
)
|
)
|
)
|
force_reload = 1;
|
force_reload = 1;
|
}
|
}
|
|
|
this_alternative[i] = (int) NO_REGS;
|
this_alternative[i] = (int) NO_REGS;
|
this_alternative_win[i] = 0;
|
this_alternative_win[i] = 0;
|
this_alternative_match_win[i] = 0;
|
this_alternative_match_win[i] = 0;
|
this_alternative_offmemok[i] = 0;
|
this_alternative_offmemok[i] = 0;
|
this_alternative_earlyclobber[i] = 0;
|
this_alternative_earlyclobber[i] = 0;
|
this_alternative_matches[i] = -1;
|
this_alternative_matches[i] = -1;
|
|
|
/* An empty constraint or empty alternative
|
/* An empty constraint or empty alternative
|
allows anything which matched the pattern. */
|
allows anything which matched the pattern. */
|
if (*p == 0 || *p == ',')
|
if (*p == 0 || *p == ',')
|
win = 1, badop = 0;
|
win = 1, badop = 0;
|
|
|
/* Scan this alternative's specs for this operand;
|
/* Scan this alternative's specs for this operand;
|
set WIN if the operand fits any letter in this alternative.
|
set WIN if the operand fits any letter in this alternative.
|
Otherwise, clear BADOP if this operand could
|
Otherwise, clear BADOP if this operand could
|
fit some letter after reloads,
|
fit some letter after reloads,
|
or set WINREG if this operand could fit after reloads
|
or set WINREG if this operand could fit after reloads
|
provided the constraint allows some registers. */
|
provided the constraint allows some registers. */
|
|
|
do
|
do
|
switch ((c = *p, len = CONSTRAINT_LEN (c, p)), c)
|
switch ((c = *p, len = CONSTRAINT_LEN (c, p)), c)
|
{
|
{
|
case '\0':
|
case '\0':
|
len = 0;
|
len = 0;
|
break;
|
break;
|
case ',':
|
case ',':
|
c = '\0';
|
c = '\0';
|
break;
|
break;
|
|
|
case '=': case '+': case '*':
|
case '=': case '+': case '*':
|
break;
|
break;
|
|
|
case '%':
|
case '%':
|
/* We only support one commutative marker, the first
|
/* We only support one commutative marker, the first
|
one. We already set commutative above. */
|
one. We already set commutative above. */
|
break;
|
break;
|
|
|
case '?':
|
case '?':
|
reject += 6;
|
reject += 6;
|
break;
|
break;
|
|
|
case '!':
|
case '!':
|
reject = 600;
|
reject = 600;
|
break;
|
break;
|
|
|
case '#':
|
case '#':
|
/* Ignore rest of this alternative as far as
|
/* Ignore rest of this alternative as far as
|
reloading is concerned. */
|
reloading is concerned. */
|
do
|
do
|
p++;
|
p++;
|
while (*p && *p != ',');
|
while (*p && *p != ',');
|
len = 0;
|
len = 0;
|
break;
|
break;
|
|
|
case '0': case '1': case '2': case '3': case '4':
|
case '0': case '1': case '2': case '3': case '4':
|
case '5': case '6': case '7': case '8': case '9':
|
case '5': case '6': case '7': case '8': case '9':
|
m = strtoul (p, &end, 10);
|
m = strtoul (p, &end, 10);
|
p = end;
|
p = end;
|
len = 0;
|
len = 0;
|
|
|
this_alternative_matches[i] = m;
|
this_alternative_matches[i] = m;
|
/* We are supposed to match a previous operand.
|
/* We are supposed to match a previous operand.
|
If we do, we win if that one did.
|
If we do, we win if that one did.
|
If we do not, count both of the operands as losers.
|
If we do not, count both of the operands as losers.
|
(This is too conservative, since most of the time
|
(This is too conservative, since most of the time
|
only a single reload insn will be needed to make
|
only a single reload insn will be needed to make
|
the two operands win. As a result, this alternative
|
the two operands win. As a result, this alternative
|
may be rejected when it is actually desirable.) */
|
may be rejected when it is actually desirable.) */
|
if ((swapped && (m != commutative || i != commutative + 1))
|
if ((swapped && (m != commutative || i != commutative + 1))
|
/* If we are matching as if two operands were swapped,
|
/* If we are matching as if two operands were swapped,
|
also pretend that operands_match had been computed
|
also pretend that operands_match had been computed
|
with swapped.
|
with swapped.
|
But if I is the second of those and C is the first,
|
But if I is the second of those and C is the first,
|
don't exchange them, because operands_match is valid
|
don't exchange them, because operands_match is valid
|
only on one side of its diagonal. */
|
only on one side of its diagonal. */
|
? (operands_match
|
? (operands_match
|
[(m == commutative || m == commutative + 1)
|
[(m == commutative || m == commutative + 1)
|
? 2 * commutative + 1 - m : m]
|
? 2 * commutative + 1 - m : m]
|
[(i == commutative || i == commutative + 1)
|
[(i == commutative || i == commutative + 1)
|
? 2 * commutative + 1 - i : i])
|
? 2 * commutative + 1 - i : i])
|
: operands_match[m][i])
|
: operands_match[m][i])
|
{
|
{
|
/* If we are matching a non-offsettable address where an
|
/* If we are matching a non-offsettable address where an
|
offsettable address was expected, then we must reject
|
offsettable address was expected, then we must reject
|
this combination, because we can't reload it. */
|
this combination, because we can't reload it. */
|
if (this_alternative_offmemok[m]
|
if (this_alternative_offmemok[m]
|
&& MEM_P (recog_data.operand[m])
|
&& MEM_P (recog_data.operand[m])
|
&& this_alternative[m] == (int) NO_REGS
|
&& this_alternative[m] == (int) NO_REGS
|
&& ! this_alternative_win[m])
|
&& ! this_alternative_win[m])
|
bad = 1;
|
bad = 1;
|
|
|
did_match = this_alternative_win[m];
|
did_match = this_alternative_win[m];
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Operands don't match. */
|
/* Operands don't match. */
|
rtx value;
|
rtx value;
|
int loc1, loc2;
|
int loc1, loc2;
|
/* Retroactively mark the operand we had to match
|
/* Retroactively mark the operand we had to match
|
as a loser, if it wasn't already. */
|
as a loser, if it wasn't already. */
|
if (this_alternative_win[m])
|
if (this_alternative_win[m])
|
losers++;
|
losers++;
|
this_alternative_win[m] = 0;
|
this_alternative_win[m] = 0;
|
if (this_alternative[m] == (int) NO_REGS)
|
if (this_alternative[m] == (int) NO_REGS)
|
bad = 1;
|
bad = 1;
|
/* But count the pair only once in the total badness of
|
/* But count the pair only once in the total badness of
|
this alternative, if the pair can be a dummy reload.
|
this alternative, if the pair can be a dummy reload.
|
The pointers in operand_loc are not swapped; swap
|
The pointers in operand_loc are not swapped; swap
|
them by hand if necessary. */
|
them by hand if necessary. */
|
if (swapped && i == commutative)
|
if (swapped && i == commutative)
|
loc1 = commutative + 1;
|
loc1 = commutative + 1;
|
else if (swapped && i == commutative + 1)
|
else if (swapped && i == commutative + 1)
|
loc1 = commutative;
|
loc1 = commutative;
|
else
|
else
|
loc1 = i;
|
loc1 = i;
|
if (swapped && m == commutative)
|
if (swapped && m == commutative)
|
loc2 = commutative + 1;
|
loc2 = commutative + 1;
|
else if (swapped && m == commutative + 1)
|
else if (swapped && m == commutative + 1)
|
loc2 = commutative;
|
loc2 = commutative;
|
else
|
else
|
loc2 = m;
|
loc2 = m;
|
value
|
value
|
= find_dummy_reload (recog_data.operand[i],
|
= find_dummy_reload (recog_data.operand[i],
|
recog_data.operand[m],
|
recog_data.operand[m],
|
recog_data.operand_loc[loc1],
|
recog_data.operand_loc[loc1],
|
recog_data.operand_loc[loc2],
|
recog_data.operand_loc[loc2],
|
operand_mode[i], operand_mode[m],
|
operand_mode[i], operand_mode[m],
|
this_alternative[m], -1,
|
this_alternative[m], -1,
|
this_alternative_earlyclobber[m]);
|
this_alternative_earlyclobber[m]);
|
|
|
if (value != 0)
|
if (value != 0)
|
losers--;
|
losers--;
|
}
|
}
|
/* This can be fixed with reloads if the operand
|
/* This can be fixed with reloads if the operand
|
we are supposed to match can be fixed with reloads. */
|
we are supposed to match can be fixed with reloads. */
|
badop = 0;
|
badop = 0;
|
this_alternative[i] = this_alternative[m];
|
this_alternative[i] = this_alternative[m];
|
|
|
/* If we have to reload this operand and some previous
|
/* If we have to reload this operand and some previous
|
operand also had to match the same thing as this
|
operand also had to match the same thing as this
|
operand, we don't know how to do that. So reject this
|
operand, we don't know how to do that. So reject this
|
alternative. */
|
alternative. */
|
if (! did_match || force_reload)
|
if (! did_match || force_reload)
|
for (j = 0; j < i; j++)
|
for (j = 0; j < i; j++)
|
if (this_alternative_matches[j]
|
if (this_alternative_matches[j]
|
== this_alternative_matches[i])
|
== this_alternative_matches[i])
|
badop = 1;
|
badop = 1;
|
break;
|
break;
|
|
|
case 'p':
|
case 'p':
|
/* All necessary reloads for an address_operand
|
/* All necessary reloads for an address_operand
|
were handled in find_reloads_address. */
|
were handled in find_reloads_address. */
|
this_alternative[i]
|
this_alternative[i]
|
= (int) base_reg_class (VOIDmode, ADDRESS, SCRATCH);
|
= (int) base_reg_class (VOIDmode, ADDRESS, SCRATCH);
|
win = 1;
|
win = 1;
|
badop = 0;
|
badop = 0;
|
break;
|
break;
|
|
|
case 'm':
|
case 'm':
|
if (force_reload)
|
if (force_reload)
|
break;
|
break;
|
if (MEM_P (operand)
|
if (MEM_P (operand)
|
|| (REG_P (operand)
|
|| (REG_P (operand)
|
&& REGNO (operand) >= FIRST_PSEUDO_REGISTER
|
&& REGNO (operand) >= FIRST_PSEUDO_REGISTER
|
&& reg_renumber[REGNO (operand)] < 0))
|
&& reg_renumber[REGNO (operand)] < 0))
|
win = 1;
|
win = 1;
|
if (CONST_POOL_OK_P (operand))
|
if (CONST_POOL_OK_P (operand))
|
badop = 0;
|
badop = 0;
|
constmemok = 1;
|
constmemok = 1;
|
break;
|
break;
|
|
|
case '<':
|
case '<':
|
if (MEM_P (operand)
|
if (MEM_P (operand)
|
&& ! address_reloaded[i]
|
&& ! address_reloaded[i]
|
&& (GET_CODE (XEXP (operand, 0)) == PRE_DEC
|
&& (GET_CODE (XEXP (operand, 0)) == PRE_DEC
|
|| GET_CODE (XEXP (operand, 0)) == POST_DEC))
|
|| GET_CODE (XEXP (operand, 0)) == POST_DEC))
|
win = 1;
|
win = 1;
|
break;
|
break;
|
|
|
case '>':
|
case '>':
|
if (MEM_P (operand)
|
if (MEM_P (operand)
|
&& ! address_reloaded[i]
|
&& ! address_reloaded[i]
|
&& (GET_CODE (XEXP (operand, 0)) == PRE_INC
|
&& (GET_CODE (XEXP (operand, 0)) == PRE_INC
|
|| GET_CODE (XEXP (operand, 0)) == POST_INC))
|
|| GET_CODE (XEXP (operand, 0)) == POST_INC))
|
win = 1;
|
win = 1;
|
break;
|
break;
|
|
|
/* Memory operand whose address is not offsettable. */
|
/* Memory operand whose address is not offsettable. */
|
case 'V':
|
case 'V':
|
if (force_reload)
|
if (force_reload)
|
break;
|
break;
|
if (MEM_P (operand)
|
if (MEM_P (operand)
|
&& ! (ind_levels ? offsettable_memref_p (operand)
|
&& ! (ind_levels ? offsettable_memref_p (operand)
|
: offsettable_nonstrict_memref_p (operand))
|
: offsettable_nonstrict_memref_p (operand))
|
/* Certain mem addresses will become offsettable
|
/* Certain mem addresses will become offsettable
|
after they themselves are reloaded. This is important;
|
after they themselves are reloaded. This is important;
|
we don't want our own handling of unoffsettables
|
we don't want our own handling of unoffsettables
|
to override the handling of reg_equiv_address. */
|
to override the handling of reg_equiv_address. */
|
&& !(REG_P (XEXP (operand, 0))
|
&& !(REG_P (XEXP (operand, 0))
|
&& (ind_levels == 0
|
&& (ind_levels == 0
|
|| reg_equiv_address[REGNO (XEXP (operand, 0))] != 0)))
|
|| reg_equiv_address[REGNO (XEXP (operand, 0))] != 0)))
|
win = 1;
|
win = 1;
|
break;
|
break;
|
|
|
/* Memory operand whose address is offsettable. */
|
/* Memory operand whose address is offsettable. */
|
case 'o':
|
case 'o':
|
if (force_reload)
|
if (force_reload)
|
break;
|
break;
|
if ((MEM_P (operand)
|
if ((MEM_P (operand)
|
/* If IND_LEVELS, find_reloads_address won't reload a
|
/* If IND_LEVELS, find_reloads_address won't reload a
|
pseudo that didn't get a hard reg, so we have to
|
pseudo that didn't get a hard reg, so we have to
|
reject that case. */
|
reject that case. */
|
&& ((ind_levels ? offsettable_memref_p (operand)
|
&& ((ind_levels ? offsettable_memref_p (operand)
|
: offsettable_nonstrict_memref_p (operand))
|
: offsettable_nonstrict_memref_p (operand))
|
/* A reloaded address is offsettable because it is now
|
/* A reloaded address is offsettable because it is now
|
just a simple register indirect. */
|
just a simple register indirect. */
|
|| address_reloaded[i] == 1))
|
|| address_reloaded[i] == 1))
|
|| (REG_P (operand)
|
|| (REG_P (operand)
|
&& REGNO (operand) >= FIRST_PSEUDO_REGISTER
|
&& REGNO (operand) >= FIRST_PSEUDO_REGISTER
|
&& reg_renumber[REGNO (operand)] < 0
|
&& reg_renumber[REGNO (operand)] < 0
|
/* If reg_equiv_address is nonzero, we will be
|
/* If reg_equiv_address is nonzero, we will be
|
loading it into a register; hence it will be
|
loading it into a register; hence it will be
|
offsettable, but we cannot say that reg_equiv_mem
|
offsettable, but we cannot say that reg_equiv_mem
|
is offsettable without checking. */
|
is offsettable without checking. */
|
&& ((reg_equiv_mem[REGNO (operand)] != 0
|
&& ((reg_equiv_mem[REGNO (operand)] != 0
|
&& offsettable_memref_p (reg_equiv_mem[REGNO (operand)]))
|
&& offsettable_memref_p (reg_equiv_mem[REGNO (operand)]))
|
|| (reg_equiv_address[REGNO (operand)] != 0))))
|
|| (reg_equiv_address[REGNO (operand)] != 0))))
|
win = 1;
|
win = 1;
|
if (CONST_POOL_OK_P (operand)
|
if (CONST_POOL_OK_P (operand)
|
|| MEM_P (operand))
|
|| MEM_P (operand))
|
badop = 0;
|
badop = 0;
|
constmemok = 1;
|
constmemok = 1;
|
offmemok = 1;
|
offmemok = 1;
|
break;
|
break;
|
|
|
case '&':
|
case '&':
|
/* Output operand that is stored before the need for the
|
/* Output operand that is stored before the need for the
|
input operands (and their index registers) is over. */
|
input operands (and their index registers) is over. */
|
earlyclobber = 1, this_earlyclobber = 1;
|
earlyclobber = 1, this_earlyclobber = 1;
|
break;
|
break;
|
|
|
case 'E':
|
case 'E':
|
case 'F':
|
case 'F':
|
if (GET_CODE (operand) == CONST_DOUBLE
|
if (GET_CODE (operand) == CONST_DOUBLE
|
|| (GET_CODE (operand) == CONST_VECTOR
|
|| (GET_CODE (operand) == CONST_VECTOR
|
&& (GET_MODE_CLASS (GET_MODE (operand))
|
&& (GET_MODE_CLASS (GET_MODE (operand))
|
== MODE_VECTOR_FLOAT)))
|
== MODE_VECTOR_FLOAT)))
|
win = 1;
|
win = 1;
|
break;
|
break;
|
|
|
case 'G':
|
case 'G':
|
case 'H':
|
case 'H':
|
if (GET_CODE (operand) == CONST_DOUBLE
|
if (GET_CODE (operand) == CONST_DOUBLE
|
&& CONST_DOUBLE_OK_FOR_CONSTRAINT_P (operand, c, p))
|
&& CONST_DOUBLE_OK_FOR_CONSTRAINT_P (operand, c, p))
|
win = 1;
|
win = 1;
|
break;
|
break;
|
|
|
case 's':
|
case 's':
|
if (GET_CODE (operand) == CONST_INT
|
if (GET_CODE (operand) == CONST_INT
|
|| (GET_CODE (operand) == CONST_DOUBLE
|
|| (GET_CODE (operand) == CONST_DOUBLE
|
&& GET_MODE (operand) == VOIDmode))
|
&& GET_MODE (operand) == VOIDmode))
|
break;
|
break;
|
case 'i':
|
case 'i':
|
if (CONSTANT_P (operand)
|
if (CONSTANT_P (operand)
|
&& (! flag_pic || LEGITIMATE_PIC_OPERAND_P (operand)))
|
&& (! flag_pic || LEGITIMATE_PIC_OPERAND_P (operand)))
|
win = 1;
|
win = 1;
|
break;
|
break;
|
|
|
case 'n':
|
case 'n':
|
if (GET_CODE (operand) == CONST_INT
|
if (GET_CODE (operand) == CONST_INT
|
|| (GET_CODE (operand) == CONST_DOUBLE
|
|| (GET_CODE (operand) == CONST_DOUBLE
|
&& GET_MODE (operand) == VOIDmode))
|
&& GET_MODE (operand) == VOIDmode))
|
win = 1;
|
win = 1;
|
break;
|
break;
|
|
|
case 'I':
|
case 'I':
|
case 'J':
|
case 'J':
|
case 'K':
|
case 'K':
|
case 'L':
|
case 'L':
|
case 'M':
|
case 'M':
|
case 'N':
|
case 'N':
|
case 'O':
|
case 'O':
|
case 'P':
|
case 'P':
|
if (GET_CODE (operand) == CONST_INT
|
if (GET_CODE (operand) == CONST_INT
|
&& CONST_OK_FOR_CONSTRAINT_P (INTVAL (operand), c, p))
|
&& CONST_OK_FOR_CONSTRAINT_P (INTVAL (operand), c, p))
|
win = 1;
|
win = 1;
|
break;
|
break;
|
|
|
case 'X':
|
case 'X':
|
force_reload = 0;
|
force_reload = 0;
|
win = 1;
|
win = 1;
|
break;
|
break;
|
|
|
case 'g':
|
case 'g':
|
if (! force_reload
|
if (! force_reload
|
/* A PLUS is never a valid operand, but reload can make
|
/* A PLUS is never a valid operand, but reload can make
|
it from a register when eliminating registers. */
|
it from a register when eliminating registers. */
|
&& GET_CODE (operand) != PLUS
|
&& GET_CODE (operand) != PLUS
|
/* A SCRATCH is not a valid operand. */
|
/* A SCRATCH is not a valid operand. */
|
&& GET_CODE (operand) != SCRATCH
|
&& GET_CODE (operand) != SCRATCH
|
&& (! CONSTANT_P (operand)
|
&& (! CONSTANT_P (operand)
|
|| ! flag_pic
|
|| ! flag_pic
|
|| LEGITIMATE_PIC_OPERAND_P (operand))
|
|| LEGITIMATE_PIC_OPERAND_P (operand))
|
&& (GENERAL_REGS == ALL_REGS
|
&& (GENERAL_REGS == ALL_REGS
|
|| !REG_P (operand)
|
|| !REG_P (operand)
|
|| (REGNO (operand) >= FIRST_PSEUDO_REGISTER
|
|| (REGNO (operand) >= FIRST_PSEUDO_REGISTER
|
&& reg_renumber[REGNO (operand)] < 0)))
|
&& reg_renumber[REGNO (operand)] < 0)))
|
win = 1;
|
win = 1;
|
/* Drop through into 'r' case. */
|
/* Drop through into 'r' case. */
|
|
|
case 'r':
|
case 'r':
|
this_alternative[i]
|
this_alternative[i]
|
= (int) reg_class_subunion[this_alternative[i]][(int) GENERAL_REGS];
|
= (int) reg_class_subunion[this_alternative[i]][(int) GENERAL_REGS];
|
goto reg;
|
goto reg;
|
|
|
default:
|
default:
|
if (REG_CLASS_FROM_CONSTRAINT (c, p) == NO_REGS)
|
if (REG_CLASS_FROM_CONSTRAINT (c, p) == NO_REGS)
|
{
|
{
|
#ifdef EXTRA_CONSTRAINT_STR
|
#ifdef EXTRA_CONSTRAINT_STR
|
if (EXTRA_MEMORY_CONSTRAINT (c, p))
|
if (EXTRA_MEMORY_CONSTRAINT (c, p))
|
{
|
{
|
if (force_reload)
|
if (force_reload)
|
break;
|
break;
|
if (EXTRA_CONSTRAINT_STR (operand, c, p))
|
if (EXTRA_CONSTRAINT_STR (operand, c, p))
|
win = 1;
|
win = 1;
|
/* If the address was already reloaded,
|
/* If the address was already reloaded,
|
we win as well. */
|
we win as well. */
|
else if (MEM_P (operand)
|
else if (MEM_P (operand)
|
&& address_reloaded[i] == 1)
|
&& address_reloaded[i] == 1)
|
win = 1;
|
win = 1;
|
/* Likewise if the address will be reloaded because
|
/* Likewise if the address will be reloaded because
|
reg_equiv_address is nonzero. For reg_equiv_mem
|
reg_equiv_address is nonzero. For reg_equiv_mem
|
we have to check. */
|
we have to check. */
|
else if (REG_P (operand)
|
else if (REG_P (operand)
|
&& REGNO (operand) >= FIRST_PSEUDO_REGISTER
|
&& REGNO (operand) >= FIRST_PSEUDO_REGISTER
|
&& reg_renumber[REGNO (operand)] < 0
|
&& reg_renumber[REGNO (operand)] < 0
|
&& ((reg_equiv_mem[REGNO (operand)] != 0
|
&& ((reg_equiv_mem[REGNO (operand)] != 0
|
&& EXTRA_CONSTRAINT_STR (reg_equiv_mem[REGNO (operand)], c, p))
|
&& EXTRA_CONSTRAINT_STR (reg_equiv_mem[REGNO (operand)], c, p))
|
|| (reg_equiv_address[REGNO (operand)] != 0)))
|
|| (reg_equiv_address[REGNO (operand)] != 0)))
|
win = 1;
|
win = 1;
|
|
|
/* If we didn't already win, we can reload
|
/* If we didn't already win, we can reload
|
constants via force_const_mem, and other
|
constants via force_const_mem, and other
|
MEMs by reloading the address like for 'o'. */
|
MEMs by reloading the address like for 'o'. */
|
if (CONST_POOL_OK_P (operand)
|
if (CONST_POOL_OK_P (operand)
|
|| MEM_P (operand))
|
|| MEM_P (operand))
|
badop = 0;
|
badop = 0;
|
constmemok = 1;
|
constmemok = 1;
|
offmemok = 1;
|
offmemok = 1;
|
break;
|
break;
|
}
|
}
|
if (EXTRA_ADDRESS_CONSTRAINT (c, p))
|
if (EXTRA_ADDRESS_CONSTRAINT (c, p))
|
{
|
{
|
if (EXTRA_CONSTRAINT_STR (operand, c, p))
|
if (EXTRA_CONSTRAINT_STR (operand, c, p))
|
win = 1;
|
win = 1;
|
|
|
/* If we didn't already win, we can reload
|
/* If we didn't already win, we can reload
|
the address into a base register. */
|
the address into a base register. */
|
this_alternative[i]
|
this_alternative[i]
|
= (int) base_reg_class (VOIDmode, ADDRESS, SCRATCH);
|
= (int) base_reg_class (VOIDmode, ADDRESS, SCRATCH);
|
badop = 0;
|
badop = 0;
|
break;
|
break;
|
}
|
}
|
|
|
if (EXTRA_CONSTRAINT_STR (operand, c, p))
|
if (EXTRA_CONSTRAINT_STR (operand, c, p))
|
win = 1;
|
win = 1;
|
#endif
|
#endif
|
break;
|
break;
|
}
|
}
|
|
|
this_alternative[i]
|
this_alternative[i]
|
= (int) (reg_class_subunion
|
= (int) (reg_class_subunion
|
[this_alternative[i]]
|
[this_alternative[i]]
|
[(int) REG_CLASS_FROM_CONSTRAINT (c, p)]);
|
[(int) REG_CLASS_FROM_CONSTRAINT (c, p)]);
|
reg:
|
reg:
|
if (GET_MODE (operand) == BLKmode)
|
if (GET_MODE (operand) == BLKmode)
|
break;
|
break;
|
winreg = 1;
|
winreg = 1;
|
if (REG_P (operand)
|
if (REG_P (operand)
|
&& reg_fits_class_p (operand, this_alternative[i],
|
&& reg_fits_class_p (operand, this_alternative[i],
|
offset, GET_MODE (recog_data.operand[i])))
|
offset, GET_MODE (recog_data.operand[i])))
|
win = 1;
|
win = 1;
|
break;
|
break;
|
}
|
}
|
while ((p += len), c);
|
while ((p += len), c);
|
|
|
constraints[i] = p;
|
constraints[i] = p;
|
|
|
/* If this operand could be handled with a reg,
|
/* If this operand could be handled with a reg,
|
and some reg is allowed, then this operand can be handled. */
|
and some reg is allowed, then this operand can be handled. */
|
if (winreg && this_alternative[i] != (int) NO_REGS)
|
if (winreg && this_alternative[i] != (int) NO_REGS)
|
badop = 0;
|
badop = 0;
|
|
|
/* Record which operands fit this alternative. */
|
/* Record which operands fit this alternative. */
|
this_alternative_earlyclobber[i] = earlyclobber;
|
this_alternative_earlyclobber[i] = earlyclobber;
|
if (win && ! force_reload)
|
if (win && ! force_reload)
|
this_alternative_win[i] = 1;
|
this_alternative_win[i] = 1;
|
else if (did_match && ! force_reload)
|
else if (did_match && ! force_reload)
|
this_alternative_match_win[i] = 1;
|
this_alternative_match_win[i] = 1;
|
else
|
else
|
{
|
{
|
int const_to_mem = 0;
|
int const_to_mem = 0;
|
|
|
this_alternative_offmemok[i] = offmemok;
|
this_alternative_offmemok[i] = offmemok;
|
losers++;
|
losers++;
|
if (badop)
|
if (badop)
|
bad = 1;
|
bad = 1;
|
/* Alternative loses if it has no regs for a reg operand. */
|
/* Alternative loses if it has no regs for a reg operand. */
|
if (REG_P (operand)
|
if (REG_P (operand)
|
&& this_alternative[i] == (int) NO_REGS
|
&& this_alternative[i] == (int) NO_REGS
|
&& this_alternative_matches[i] < 0)
|
&& this_alternative_matches[i] < 0)
|
bad = 1;
|
bad = 1;
|
|
|
/* If this is a constant that is reloaded into the desired
|
/* If this is a constant that is reloaded into the desired
|
class by copying it to memory first, count that as another
|
class by copying it to memory first, count that as another
|
reload. This is consistent with other code and is
|
reload. This is consistent with other code and is
|
required to avoid choosing another alternative when
|
required to avoid choosing another alternative when
|
the constant is moved into memory by this function on
|
the constant is moved into memory by this function on
|
an early reload pass. Note that the test here is
|
an early reload pass. Note that the test here is
|
precisely the same as in the code below that calls
|
precisely the same as in the code below that calls
|
force_const_mem. */
|
force_const_mem. */
|
if (CONST_POOL_OK_P (operand)
|
if (CONST_POOL_OK_P (operand)
|
&& ((PREFERRED_RELOAD_CLASS (operand,
|
&& ((PREFERRED_RELOAD_CLASS (operand,
|
(enum reg_class) this_alternative[i])
|
(enum reg_class) this_alternative[i])
|
== NO_REGS)
|
== NO_REGS)
|
|| no_input_reloads)
|
|| no_input_reloads)
|
&& operand_mode[i] != VOIDmode)
|
&& operand_mode[i] != VOIDmode)
|
{
|
{
|
const_to_mem = 1;
|
const_to_mem = 1;
|
if (this_alternative[i] != (int) NO_REGS)
|
if (this_alternative[i] != (int) NO_REGS)
|
losers++;
|
losers++;
|
}
|
}
|
|
|
/* Alternative loses if it requires a type of reload not
|
/* Alternative loses if it requires a type of reload not
|
permitted for this insn. We can always reload SCRATCH
|
permitted for this insn. We can always reload SCRATCH
|
and objects with a REG_UNUSED note. */
|
and objects with a REG_UNUSED note. */
|
if (GET_CODE (operand) != SCRATCH
|
if (GET_CODE (operand) != SCRATCH
|
&& modified[i] != RELOAD_READ && no_output_reloads
|
&& modified[i] != RELOAD_READ && no_output_reloads
|
&& ! find_reg_note (insn, REG_UNUSED, operand))
|
&& ! find_reg_note (insn, REG_UNUSED, operand))
|
bad = 1;
|
bad = 1;
|
else if (modified[i] != RELOAD_WRITE && no_input_reloads
|
else if (modified[i] != RELOAD_WRITE && no_input_reloads
|
&& ! const_to_mem)
|
&& ! const_to_mem)
|
bad = 1;
|
bad = 1;
|
|
|
/* If we can't reload this value at all, reject this
|
/* If we can't reload this value at all, reject this
|
alternative. Note that we could also lose due to
|
alternative. Note that we could also lose due to
|
LIMIT_RELOAD_CLASS, but we don't check that
|
LIMIT_RELOAD_CLASS, but we don't check that
|
here. */
|
here. */
|
|
|
if (! CONSTANT_P (operand)
|
if (! CONSTANT_P (operand)
|
&& (enum reg_class) this_alternative[i] != NO_REGS)
|
&& (enum reg_class) this_alternative[i] != NO_REGS)
|
{
|
{
|
if (PREFERRED_RELOAD_CLASS
|
if (PREFERRED_RELOAD_CLASS
|
(operand, (enum reg_class) this_alternative[i])
|
(operand, (enum reg_class) this_alternative[i])
|
== NO_REGS)
|
== NO_REGS)
|
reject = 600;
|
reject = 600;
|
|
|
#ifdef PREFERRED_OUTPUT_RELOAD_CLASS
|
#ifdef PREFERRED_OUTPUT_RELOAD_CLASS
|
if (operand_type[i] == RELOAD_FOR_OUTPUT
|
if (operand_type[i] == RELOAD_FOR_OUTPUT
|
&& PREFERRED_OUTPUT_RELOAD_CLASS
|
&& PREFERRED_OUTPUT_RELOAD_CLASS
|
(operand, (enum reg_class) this_alternative[i])
|
(operand, (enum reg_class) this_alternative[i])
|
== NO_REGS)
|
== NO_REGS)
|
reject = 600;
|
reject = 600;
|
#endif
|
#endif
|
}
|
}
|
|
|
/* We prefer to reload pseudos over reloading other things,
|
/* We prefer to reload pseudos over reloading other things,
|
since such reloads may be able to be eliminated later.
|
since such reloads may be able to be eliminated later.
|
If we are reloading a SCRATCH, we won't be generating any
|
If we are reloading a SCRATCH, we won't be generating any
|
insns, just using a register, so it is also preferred.
|
insns, just using a register, so it is also preferred.
|
So bump REJECT in other cases. Don't do this in the
|
So bump REJECT in other cases. Don't do this in the
|
case where we are forcing a constant into memory and
|
case where we are forcing a constant into memory and
|
it will then win since we don't want to have a different
|
it will then win since we don't want to have a different
|
alternative match then. */
|
alternative match then. */
|
if (! (REG_P (operand)
|
if (! (REG_P (operand)
|
&& REGNO (operand) >= FIRST_PSEUDO_REGISTER)
|
&& REGNO (operand) >= FIRST_PSEUDO_REGISTER)
|
&& GET_CODE (operand) != SCRATCH
|
&& GET_CODE (operand) != SCRATCH
|
&& ! (const_to_mem && constmemok))
|
&& ! (const_to_mem && constmemok))
|
reject += 2;
|
reject += 2;
|
|
|
/* Input reloads can be inherited more often than output
|
/* Input reloads can be inherited more often than output
|
reloads can be removed, so penalize output reloads. */
|
reloads can be removed, so penalize output reloads. */
|
if (operand_type[i] != RELOAD_FOR_INPUT
|
if (operand_type[i] != RELOAD_FOR_INPUT
|
&& GET_CODE (operand) != SCRATCH)
|
&& GET_CODE (operand) != SCRATCH)
|
reject++;
|
reject++;
|
}
|
}
|
|
|
/* If this operand is a pseudo register that didn't get a hard
|
/* If this operand is a pseudo register that didn't get a hard
|
reg and this alternative accepts some register, see if the
|
reg and this alternative accepts some register, see if the
|
class that we want is a subset of the preferred class for this
|
class that we want is a subset of the preferred class for this
|
register. If not, but it intersects that class, use the
|
register. If not, but it intersects that class, use the
|
preferred class instead. If it does not intersect the preferred
|
preferred class instead. If it does not intersect the preferred
|
class, show that usage of this alternative should be discouraged;
|
class, show that usage of this alternative should be discouraged;
|
it will be discouraged more still if the register is `preferred
|
it will be discouraged more still if the register is `preferred
|
or nothing'. We do this because it increases the chance of
|
or nothing'. We do this because it increases the chance of
|
reusing our spill register in a later insn and avoiding a pair
|
reusing our spill register in a later insn and avoiding a pair
|
of memory stores and loads.
|
of memory stores and loads.
|
|
|
Don't bother with this if this alternative will accept this
|
Don't bother with this if this alternative will accept this
|
operand.
|
operand.
|
|
|
Don't do this for a multiword operand, since it is only a
|
Don't do this for a multiword operand, since it is only a
|
small win and has the risk of requiring more spill registers,
|
small win and has the risk of requiring more spill registers,
|
which could cause a large loss.
|
which could cause a large loss.
|
|
|
Don't do this if the preferred class has only one register
|
Don't do this if the preferred class has only one register
|
because we might otherwise exhaust the class. */
|
because we might otherwise exhaust the class. */
|
|
|
if (! win && ! did_match
|
if (! win && ! did_match
|
&& this_alternative[i] != (int) NO_REGS
|
&& this_alternative[i] != (int) NO_REGS
|
&& GET_MODE_SIZE (operand_mode[i]) <= UNITS_PER_WORD
|
&& GET_MODE_SIZE (operand_mode[i]) <= UNITS_PER_WORD
|
&& reg_class_size [(int) preferred_class[i]] > 0
|
&& reg_class_size [(int) preferred_class[i]] > 0
|
&& ! SMALL_REGISTER_CLASS_P (preferred_class[i]))
|
&& ! SMALL_REGISTER_CLASS_P (preferred_class[i]))
|
{
|
{
|
if (! reg_class_subset_p (this_alternative[i],
|
if (! reg_class_subset_p (this_alternative[i],
|
preferred_class[i]))
|
preferred_class[i]))
|
{
|
{
|
/* Since we don't have a way of forming the intersection,
|
/* Since we don't have a way of forming the intersection,
|
we just do something special if the preferred class
|
we just do something special if the preferred class
|
is a subset of the class we have; that's the most
|
is a subset of the class we have; that's the most
|
common case anyway. */
|
common case anyway. */
|
if (reg_class_subset_p (preferred_class[i],
|
if (reg_class_subset_p (preferred_class[i],
|
this_alternative[i]))
|
this_alternative[i]))
|
this_alternative[i] = (int) preferred_class[i];
|
this_alternative[i] = (int) preferred_class[i];
|
else
|
else
|
reject += (2 + 2 * pref_or_nothing[i]);
|
reject += (2 + 2 * pref_or_nothing[i]);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Now see if any output operands that are marked "earlyclobber"
|
/* Now see if any output operands that are marked "earlyclobber"
|
in this alternative conflict with any input operands
|
in this alternative conflict with any input operands
|
or any memory addresses. */
|
or any memory addresses. */
|
|
|
for (i = 0; i < noperands; i++)
|
for (i = 0; i < noperands; i++)
|
if (this_alternative_earlyclobber[i]
|
if (this_alternative_earlyclobber[i]
|
&& (this_alternative_win[i] || this_alternative_match_win[i]))
|
&& (this_alternative_win[i] || this_alternative_match_win[i]))
|
{
|
{
|
struct decomposition early_data;
|
struct decomposition early_data;
|
|
|
early_data = decompose (recog_data.operand[i]);
|
early_data = decompose (recog_data.operand[i]);
|
|
|
gcc_assert (modified[i] != RELOAD_READ);
|
gcc_assert (modified[i] != RELOAD_READ);
|
|
|
if (this_alternative[i] == NO_REGS)
|
if (this_alternative[i] == NO_REGS)
|
{
|
{
|
this_alternative_earlyclobber[i] = 0;
|
this_alternative_earlyclobber[i] = 0;
|
gcc_assert (this_insn_is_asm);
|
gcc_assert (this_insn_is_asm);
|
error_for_asm (this_insn,
|
error_for_asm (this_insn,
|
"%<&%> constraint used with no register class");
|
"%<&%> constraint used with no register class");
|
}
|
}
|
|
|
for (j = 0; j < noperands; j++)
|
for (j = 0; j < noperands; j++)
|
/* Is this an input operand or a memory ref? */
|
/* Is this an input operand or a memory ref? */
|
if ((MEM_P (recog_data.operand[j])
|
if ((MEM_P (recog_data.operand[j])
|
|| modified[j] != RELOAD_WRITE)
|
|| modified[j] != RELOAD_WRITE)
|
&& j != i
|
&& j != i
|
/* Ignore things like match_operator operands. */
|
/* Ignore things like match_operator operands. */
|
&& *recog_data.constraints[j] != 0
|
&& *recog_data.constraints[j] != 0
|
/* Don't count an input operand that is constrained to match
|
/* Don't count an input operand that is constrained to match
|
the early clobber operand. */
|
the early clobber operand. */
|
&& ! (this_alternative_matches[j] == i
|
&& ! (this_alternative_matches[j] == i
|
&& rtx_equal_p (recog_data.operand[i],
|
&& rtx_equal_p (recog_data.operand[i],
|
recog_data.operand[j]))
|
recog_data.operand[j]))
|
/* Is it altered by storing the earlyclobber operand? */
|
/* Is it altered by storing the earlyclobber operand? */
|
&& !immune_p (recog_data.operand[j], recog_data.operand[i],
|
&& !immune_p (recog_data.operand[j], recog_data.operand[i],
|
early_data))
|
early_data))
|
{
|
{
|
/* If the output is in a non-empty few-regs class,
|
/* If the output is in a non-empty few-regs class,
|
it's costly to reload it, so reload the input instead. */
|
it's costly to reload it, so reload the input instead. */
|
if (SMALL_REGISTER_CLASS_P (this_alternative[i])
|
if (SMALL_REGISTER_CLASS_P (this_alternative[i])
|
&& (REG_P (recog_data.operand[j])
|
&& (REG_P (recog_data.operand[j])
|
|| GET_CODE (recog_data.operand[j]) == SUBREG))
|
|| GET_CODE (recog_data.operand[j]) == SUBREG))
|
{
|
{
|
losers++;
|
losers++;
|
this_alternative_win[j] = 0;
|
this_alternative_win[j] = 0;
|
this_alternative_match_win[j] = 0;
|
this_alternative_match_win[j] = 0;
|
}
|
}
|
else
|
else
|
break;
|
break;
|
}
|
}
|
/* If an earlyclobber operand conflicts with something,
|
/* If an earlyclobber operand conflicts with something,
|
it must be reloaded, so request this and count the cost. */
|
it must be reloaded, so request this and count the cost. */
|
if (j != noperands)
|
if (j != noperands)
|
{
|
{
|
losers++;
|
losers++;
|
this_alternative_win[i] = 0;
|
this_alternative_win[i] = 0;
|
this_alternative_match_win[j] = 0;
|
this_alternative_match_win[j] = 0;
|
for (j = 0; j < noperands; j++)
|
for (j = 0; j < noperands; j++)
|
if (this_alternative_matches[j] == i
|
if (this_alternative_matches[j] == i
|
&& this_alternative_match_win[j])
|
&& this_alternative_match_win[j])
|
{
|
{
|
this_alternative_win[j] = 0;
|
this_alternative_win[j] = 0;
|
this_alternative_match_win[j] = 0;
|
this_alternative_match_win[j] = 0;
|
losers++;
|
losers++;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* If one alternative accepts all the operands, no reload required,
|
/* If one alternative accepts all the operands, no reload required,
|
choose that alternative; don't consider the remaining ones. */
|
choose that alternative; don't consider the remaining ones. */
|
if (losers == 0)
|
if (losers == 0)
|
{
|
{
|
/* Unswap these so that they are never swapped at `finish'. */
|
/* Unswap these so that they are never swapped at `finish'. */
|
if (commutative >= 0)
|
if (commutative >= 0)
|
{
|
{
|
recog_data.operand[commutative] = substed_operand[commutative];
|
recog_data.operand[commutative] = substed_operand[commutative];
|
recog_data.operand[commutative + 1]
|
recog_data.operand[commutative + 1]
|
= substed_operand[commutative + 1];
|
= substed_operand[commutative + 1];
|
}
|
}
|
for (i = 0; i < noperands; i++)
|
for (i = 0; i < noperands; i++)
|
{
|
{
|
goal_alternative_win[i] = this_alternative_win[i];
|
goal_alternative_win[i] = this_alternative_win[i];
|
goal_alternative_match_win[i] = this_alternative_match_win[i];
|
goal_alternative_match_win[i] = this_alternative_match_win[i];
|
goal_alternative[i] = this_alternative[i];
|
goal_alternative[i] = this_alternative[i];
|
goal_alternative_offmemok[i] = this_alternative_offmemok[i];
|
goal_alternative_offmemok[i] = this_alternative_offmemok[i];
|
goal_alternative_matches[i] = this_alternative_matches[i];
|
goal_alternative_matches[i] = this_alternative_matches[i];
|
goal_alternative_earlyclobber[i]
|
goal_alternative_earlyclobber[i]
|
= this_alternative_earlyclobber[i];
|
= this_alternative_earlyclobber[i];
|
}
|
}
|
goal_alternative_number = this_alternative_number;
|
goal_alternative_number = this_alternative_number;
|
goal_alternative_swapped = swapped;
|
goal_alternative_swapped = swapped;
|
goal_earlyclobber = this_earlyclobber;
|
goal_earlyclobber = this_earlyclobber;
|
goto finish;
|
goto finish;
|
}
|
}
|
|
|
/* REJECT, set by the ! and ? constraint characters and when a register
|
/* REJECT, set by the ! and ? constraint characters and when a register
|
would be reloaded into a non-preferred class, discourages the use of
|
would be reloaded into a non-preferred class, discourages the use of
|
this alternative for a reload goal. REJECT is incremented by six
|
this alternative for a reload goal. REJECT is incremented by six
|
for each ? and two for each non-preferred class. */
|
for each ? and two for each non-preferred class. */
|
losers = losers * 6 + reject;
|
losers = losers * 6 + reject;
|
|
|
/* If this alternative can be made to work by reloading,
|
/* If this alternative can be made to work by reloading,
|
and it needs less reloading than the others checked so far,
|
and it needs less reloading than the others checked so far,
|
record it as the chosen goal for reloading. */
|
record it as the chosen goal for reloading. */
|
if (! bad && best > losers)
|
if (! bad && best > losers)
|
{
|
{
|
for (i = 0; i < noperands; i++)
|
for (i = 0; i < noperands; i++)
|
{
|
{
|
goal_alternative[i] = this_alternative[i];
|
goal_alternative[i] = this_alternative[i];
|
goal_alternative_win[i] = this_alternative_win[i];
|
goal_alternative_win[i] = this_alternative_win[i];
|
goal_alternative_match_win[i] = this_alternative_match_win[i];
|
goal_alternative_match_win[i] = this_alternative_match_win[i];
|
goal_alternative_offmemok[i] = this_alternative_offmemok[i];
|
goal_alternative_offmemok[i] = this_alternative_offmemok[i];
|
goal_alternative_matches[i] = this_alternative_matches[i];
|
goal_alternative_matches[i] = this_alternative_matches[i];
|
goal_alternative_earlyclobber[i]
|
goal_alternative_earlyclobber[i]
|
= this_alternative_earlyclobber[i];
|
= this_alternative_earlyclobber[i];
|
}
|
}
|
goal_alternative_swapped = swapped;
|
goal_alternative_swapped = swapped;
|
best = losers;
|
best = losers;
|
goal_alternative_number = this_alternative_number;
|
goal_alternative_number = this_alternative_number;
|
goal_earlyclobber = this_earlyclobber;
|
goal_earlyclobber = this_earlyclobber;
|
}
|
}
|
}
|
}
|
|
|
/* If insn is commutative (it's safe to exchange a certain pair of operands)
|
/* If insn is commutative (it's safe to exchange a certain pair of operands)
|
then we need to try each alternative twice,
|
then we need to try each alternative twice,
|
the second time matching those two operands
|
the second time matching those two operands
|
as if we had exchanged them.
|
as if we had exchanged them.
|
To do this, really exchange them in operands.
|
To do this, really exchange them in operands.
|
|
|
If we have just tried the alternatives the second time,
|
If we have just tried the alternatives the second time,
|
return operands to normal and drop through. */
|
return operands to normal and drop through. */
|
|
|
if (commutative >= 0)
|
if (commutative >= 0)
|
{
|
{
|
swapped = !swapped;
|
swapped = !swapped;
|
if (swapped)
|
if (swapped)
|
{
|
{
|
enum reg_class tclass;
|
enum reg_class tclass;
|
int t;
|
int t;
|
|
|
recog_data.operand[commutative] = substed_operand[commutative + 1];
|
recog_data.operand[commutative] = substed_operand[commutative + 1];
|
recog_data.operand[commutative + 1] = substed_operand[commutative];
|
recog_data.operand[commutative + 1] = substed_operand[commutative];
|
/* Swap the duplicates too. */
|
/* Swap the duplicates too. */
|
for (i = 0; i < recog_data.n_dups; i++)
|
for (i = 0; i < recog_data.n_dups; i++)
|
if (recog_data.dup_num[i] == commutative
|
if (recog_data.dup_num[i] == commutative
|
|| recog_data.dup_num[i] == commutative + 1)
|
|| recog_data.dup_num[i] == commutative + 1)
|
*recog_data.dup_loc[i]
|
*recog_data.dup_loc[i]
|
= recog_data.operand[(int) recog_data.dup_num[i]];
|
= recog_data.operand[(int) recog_data.dup_num[i]];
|
|
|
tclass = preferred_class[commutative];
|
tclass = preferred_class[commutative];
|
preferred_class[commutative] = preferred_class[commutative + 1];
|
preferred_class[commutative] = preferred_class[commutative + 1];
|
preferred_class[commutative + 1] = tclass;
|
preferred_class[commutative + 1] = tclass;
|
|
|
t = pref_or_nothing[commutative];
|
t = pref_or_nothing[commutative];
|
pref_or_nothing[commutative] = pref_or_nothing[commutative + 1];
|
pref_or_nothing[commutative] = pref_or_nothing[commutative + 1];
|
pref_or_nothing[commutative + 1] = t;
|
pref_or_nothing[commutative + 1] = t;
|
|
|
t = address_reloaded[commutative];
|
t = address_reloaded[commutative];
|
address_reloaded[commutative] = address_reloaded[commutative + 1];
|
address_reloaded[commutative] = address_reloaded[commutative + 1];
|
address_reloaded[commutative + 1] = t;
|
address_reloaded[commutative + 1] = t;
|
|
|
memcpy (constraints, recog_data.constraints,
|
memcpy (constraints, recog_data.constraints,
|
noperands * sizeof (char *));
|
noperands * sizeof (char *));
|
goto try_swapped;
|
goto try_swapped;
|
}
|
}
|
else
|
else
|
{
|
{
|
recog_data.operand[commutative] = substed_operand[commutative];
|
recog_data.operand[commutative] = substed_operand[commutative];
|
recog_data.operand[commutative + 1]
|
recog_data.operand[commutative + 1]
|
= substed_operand[commutative + 1];
|
= substed_operand[commutative + 1];
|
/* Unswap the duplicates too. */
|
/* Unswap the duplicates too. */
|
for (i = 0; i < recog_data.n_dups; i++)
|
for (i = 0; i < recog_data.n_dups; i++)
|
if (recog_data.dup_num[i] == commutative
|
if (recog_data.dup_num[i] == commutative
|
|| recog_data.dup_num[i] == commutative + 1)
|
|| recog_data.dup_num[i] == commutative + 1)
|
*recog_data.dup_loc[i]
|
*recog_data.dup_loc[i]
|
= recog_data.operand[(int) recog_data.dup_num[i]];
|
= recog_data.operand[(int) recog_data.dup_num[i]];
|
}
|
}
|
}
|
}
|
|
|
/* The operands don't meet the constraints.
|
/* The operands don't meet the constraints.
|
goal_alternative describes the alternative
|
goal_alternative describes the alternative
|
that we could reach by reloading the fewest operands.
|
that we could reach by reloading the fewest operands.
|
Reload so as to fit it. */
|
Reload so as to fit it. */
|
|
|
if (best == MAX_RECOG_OPERANDS * 2 + 600)
|
if (best == MAX_RECOG_OPERANDS * 2 + 600)
|
{
|
{
|
/* No alternative works with reloads?? */
|
/* No alternative works with reloads?? */
|
if (insn_code_number >= 0)
|
if (insn_code_number >= 0)
|
fatal_insn ("unable to generate reloads for:", insn);
|
fatal_insn ("unable to generate reloads for:", insn);
|
error_for_asm (insn, "inconsistent operand constraints in an %<asm%>");
|
error_for_asm (insn, "inconsistent operand constraints in an %<asm%>");
|
/* Avoid further trouble with this insn. */
|
/* Avoid further trouble with this insn. */
|
PATTERN (insn) = gen_rtx_USE (VOIDmode, const0_rtx);
|
PATTERN (insn) = gen_rtx_USE (VOIDmode, const0_rtx);
|
n_reloads = 0;
|
n_reloads = 0;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Jump to `finish' from above if all operands are valid already.
|
/* Jump to `finish' from above if all operands are valid already.
|
In that case, goal_alternative_win is all 1. */
|
In that case, goal_alternative_win is all 1. */
|
finish:
|
finish:
|
|
|
/* Right now, for any pair of operands I and J that are required to match,
|
/* Right now, for any pair of operands I and J that are required to match,
|
with I < J,
|
with I < J,
|
goal_alternative_matches[J] is I.
|
goal_alternative_matches[J] is I.
|
Set up goal_alternative_matched as the inverse function:
|
Set up goal_alternative_matched as the inverse function:
|
goal_alternative_matched[I] = J. */
|
goal_alternative_matched[I] = J. */
|
|
|
for (i = 0; i < noperands; i++)
|
for (i = 0; i < noperands; i++)
|
goal_alternative_matched[i] = -1;
|
goal_alternative_matched[i] = -1;
|
|
|
for (i = 0; i < noperands; i++)
|
for (i = 0; i < noperands; i++)
|
if (! goal_alternative_win[i]
|
if (! goal_alternative_win[i]
|
&& goal_alternative_matches[i] >= 0)
|
&& goal_alternative_matches[i] >= 0)
|
goal_alternative_matched[goal_alternative_matches[i]] = i;
|
goal_alternative_matched[goal_alternative_matches[i]] = i;
|
|
|
for (i = 0; i < noperands; i++)
|
for (i = 0; i < noperands; i++)
|
goal_alternative_win[i] |= goal_alternative_match_win[i];
|
goal_alternative_win[i] |= goal_alternative_match_win[i];
|
|
|
/* If the best alternative is with operands 1 and 2 swapped,
|
/* If the best alternative is with operands 1 and 2 swapped,
|
consider them swapped before reporting the reloads. Update the
|
consider them swapped before reporting the reloads. Update the
|
operand numbers of any reloads already pushed. */
|
operand numbers of any reloads already pushed. */
|
|
|
if (goal_alternative_swapped)
|
if (goal_alternative_swapped)
|
{
|
{
|
rtx tem;
|
rtx tem;
|
|
|
tem = substed_operand[commutative];
|
tem = substed_operand[commutative];
|
substed_operand[commutative] = substed_operand[commutative + 1];
|
substed_operand[commutative] = substed_operand[commutative + 1];
|
substed_operand[commutative + 1] = tem;
|
substed_operand[commutative + 1] = tem;
|
tem = recog_data.operand[commutative];
|
tem = recog_data.operand[commutative];
|
recog_data.operand[commutative] = recog_data.operand[commutative + 1];
|
recog_data.operand[commutative] = recog_data.operand[commutative + 1];
|
recog_data.operand[commutative + 1] = tem;
|
recog_data.operand[commutative + 1] = tem;
|
tem = *recog_data.operand_loc[commutative];
|
tem = *recog_data.operand_loc[commutative];
|
*recog_data.operand_loc[commutative]
|
*recog_data.operand_loc[commutative]
|
= *recog_data.operand_loc[commutative + 1];
|
= *recog_data.operand_loc[commutative + 1];
|
*recog_data.operand_loc[commutative + 1] = tem;
|
*recog_data.operand_loc[commutative + 1] = tem;
|
|
|
for (i = 0; i < n_reloads; i++)
|
for (i = 0; i < n_reloads; i++)
|
{
|
{
|
if (rld[i].opnum == commutative)
|
if (rld[i].opnum == commutative)
|
rld[i].opnum = commutative + 1;
|
rld[i].opnum = commutative + 1;
|
else if (rld[i].opnum == commutative + 1)
|
else if (rld[i].opnum == commutative + 1)
|
rld[i].opnum = commutative;
|
rld[i].opnum = commutative;
|
}
|
}
|
}
|
}
|
|
|
for (i = 0; i < noperands; i++)
|
for (i = 0; i < noperands; i++)
|
{
|
{
|
operand_reloadnum[i] = -1;
|
operand_reloadnum[i] = -1;
|
|
|
/* If this is an earlyclobber operand, we need to widen the scope.
|
/* If this is an earlyclobber operand, we need to widen the scope.
|
The reload must remain valid from the start of the insn being
|
The reload must remain valid from the start of the insn being
|
reloaded until after the operand is stored into its destination.
|
reloaded until after the operand is stored into its destination.
|
We approximate this with RELOAD_OTHER even though we know that we
|
We approximate this with RELOAD_OTHER even though we know that we
|
do not conflict with RELOAD_FOR_INPUT_ADDRESS reloads.
|
do not conflict with RELOAD_FOR_INPUT_ADDRESS reloads.
|
|
|
One special case that is worth checking is when we have an
|
One special case that is worth checking is when we have an
|
output that is earlyclobber but isn't used past the insn (typically
|
output that is earlyclobber but isn't used past the insn (typically
|
a SCRATCH). In this case, we only need have the reload live
|
a SCRATCH). In this case, we only need have the reload live
|
through the insn itself, but not for any of our input or output
|
through the insn itself, but not for any of our input or output
|
reloads.
|
reloads.
|
But we must not accidentally narrow the scope of an existing
|
But we must not accidentally narrow the scope of an existing
|
RELOAD_OTHER reload - leave these alone.
|
RELOAD_OTHER reload - leave these alone.
|
|
|
In any case, anything needed to address this operand can remain
|
In any case, anything needed to address this operand can remain
|
however they were previously categorized. */
|
however they were previously categorized. */
|
|
|
if (goal_alternative_earlyclobber[i] && operand_type[i] != RELOAD_OTHER)
|
if (goal_alternative_earlyclobber[i] && operand_type[i] != RELOAD_OTHER)
|
operand_type[i]
|
operand_type[i]
|
= (find_reg_note (insn, REG_UNUSED, recog_data.operand[i])
|
= (find_reg_note (insn, REG_UNUSED, recog_data.operand[i])
|
? RELOAD_FOR_INSN : RELOAD_OTHER);
|
? RELOAD_FOR_INSN : RELOAD_OTHER);
|
}
|
}
|
|
|
/* Any constants that aren't allowed and can't be reloaded
|
/* Any constants that aren't allowed and can't be reloaded
|
into registers are here changed into memory references. */
|
into registers are here changed into memory references. */
|
for (i = 0; i < noperands; i++)
|
for (i = 0; i < noperands; i++)
|
if (! goal_alternative_win[i]
|
if (! goal_alternative_win[i]
|
&& CONST_POOL_OK_P (recog_data.operand[i])
|
&& CONST_POOL_OK_P (recog_data.operand[i])
|
&& ((PREFERRED_RELOAD_CLASS (recog_data.operand[i],
|
&& ((PREFERRED_RELOAD_CLASS (recog_data.operand[i],
|
(enum reg_class) goal_alternative[i])
|
(enum reg_class) goal_alternative[i])
|
== NO_REGS)
|
== NO_REGS)
|
|| no_input_reloads)
|
|| no_input_reloads)
|
&& operand_mode[i] != VOIDmode)
|
&& operand_mode[i] != VOIDmode)
|
{
|
{
|
substed_operand[i] = recog_data.operand[i]
|
substed_operand[i] = recog_data.operand[i]
|
= find_reloads_toplev (force_const_mem (operand_mode[i],
|
= find_reloads_toplev (force_const_mem (operand_mode[i],
|
recog_data.operand[i]),
|
recog_data.operand[i]),
|
i, address_type[i], ind_levels, 0, insn,
|
i, address_type[i], ind_levels, 0, insn,
|
NULL);
|
NULL);
|
if (alternative_allows_memconst (recog_data.constraints[i],
|
if (alternative_allows_memconst (recog_data.constraints[i],
|
goal_alternative_number))
|
goal_alternative_number))
|
goal_alternative_win[i] = 1;
|
goal_alternative_win[i] = 1;
|
}
|
}
|
|
|
/* Likewise any invalid constants appearing as operand of a PLUS
|
/* Likewise any invalid constants appearing as operand of a PLUS
|
that is to be reloaded. */
|
that is to be reloaded. */
|
for (i = 0; i < noperands; i++)
|
for (i = 0; i < noperands; i++)
|
if (! goal_alternative_win[i]
|
if (! goal_alternative_win[i]
|
&& GET_CODE (recog_data.operand[i]) == PLUS
|
&& GET_CODE (recog_data.operand[i]) == PLUS
|
&& CONST_POOL_OK_P (XEXP (recog_data.operand[i], 1))
|
&& CONST_POOL_OK_P (XEXP (recog_data.operand[i], 1))
|
&& (PREFERRED_RELOAD_CLASS (XEXP (recog_data.operand[i], 1),
|
&& (PREFERRED_RELOAD_CLASS (XEXP (recog_data.operand[i], 1),
|
(enum reg_class) goal_alternative[i])
|
(enum reg_class) goal_alternative[i])
|
== NO_REGS)
|
== NO_REGS)
|
&& operand_mode[i] != VOIDmode)
|
&& operand_mode[i] != VOIDmode)
|
{
|
{
|
rtx tem = force_const_mem (operand_mode[i],
|
rtx tem = force_const_mem (operand_mode[i],
|
XEXP (recog_data.operand[i], 1));
|
XEXP (recog_data.operand[i], 1));
|
tem = gen_rtx_PLUS (operand_mode[i],
|
tem = gen_rtx_PLUS (operand_mode[i],
|
XEXP (recog_data.operand[i], 0), tem);
|
XEXP (recog_data.operand[i], 0), tem);
|
|
|
substed_operand[i] = recog_data.operand[i]
|
substed_operand[i] = recog_data.operand[i]
|
= find_reloads_toplev (tem, i, address_type[i],
|
= find_reloads_toplev (tem, i, address_type[i],
|
ind_levels, 0, insn, NULL);
|
ind_levels, 0, insn, NULL);
|
}
|
}
|
|
|
/* Record the values of the earlyclobber operands for the caller. */
|
/* Record the values of the earlyclobber operands for the caller. */
|
if (goal_earlyclobber)
|
if (goal_earlyclobber)
|
for (i = 0; i < noperands; i++)
|
for (i = 0; i < noperands; i++)
|
if (goal_alternative_earlyclobber[i])
|
if (goal_alternative_earlyclobber[i])
|
reload_earlyclobbers[n_earlyclobbers++] = recog_data.operand[i];
|
reload_earlyclobbers[n_earlyclobbers++] = recog_data.operand[i];
|
|
|
/* Now record reloads for all the operands that need them. */
|
/* Now record reloads for all the operands that need them. */
|
for (i = 0; i < noperands; i++)
|
for (i = 0; i < noperands; i++)
|
if (! goal_alternative_win[i])
|
if (! goal_alternative_win[i])
|
{
|
{
|
/* Operands that match previous ones have already been handled. */
|
/* Operands that match previous ones have already been handled. */
|
if (goal_alternative_matches[i] >= 0)
|
if (goal_alternative_matches[i] >= 0)
|
;
|
;
|
/* Handle an operand with a nonoffsettable address
|
/* Handle an operand with a nonoffsettable address
|
appearing where an offsettable address will do
|
appearing where an offsettable address will do
|
by reloading the address into a base register.
|
by reloading the address into a base register.
|
|
|
??? We can also do this when the operand is a register and
|
??? We can also do this when the operand is a register and
|
reg_equiv_mem is not offsettable, but this is a bit tricky,
|
reg_equiv_mem is not offsettable, but this is a bit tricky,
|
so we don't bother with it. It may not be worth doing. */
|
so we don't bother with it. It may not be worth doing. */
|
else if (goal_alternative_matched[i] == -1
|
else if (goal_alternative_matched[i] == -1
|
&& goal_alternative_offmemok[i]
|
&& goal_alternative_offmemok[i]
|
&& MEM_P (recog_data.operand[i]))
|
&& MEM_P (recog_data.operand[i]))
|
{
|
{
|
/* If the address to be reloaded is a VOIDmode constant,
|
/* If the address to be reloaded is a VOIDmode constant,
|
use Pmode as mode of the reload register, as would have
|
use Pmode as mode of the reload register, as would have
|
been done by find_reloads_address. */
|
been done by find_reloads_address. */
|
enum machine_mode address_mode;
|
enum machine_mode address_mode;
|
address_mode = GET_MODE (XEXP (recog_data.operand[i], 0));
|
address_mode = GET_MODE (XEXP (recog_data.operand[i], 0));
|
if (address_mode == VOIDmode)
|
if (address_mode == VOIDmode)
|
address_mode = Pmode;
|
address_mode = Pmode;
|
|
|
operand_reloadnum[i]
|
operand_reloadnum[i]
|
= push_reload (XEXP (recog_data.operand[i], 0), NULL_RTX,
|
= push_reload (XEXP (recog_data.operand[i], 0), NULL_RTX,
|
&XEXP (recog_data.operand[i], 0), (rtx*) 0,
|
&XEXP (recog_data.operand[i], 0), (rtx*) 0,
|
base_reg_class (VOIDmode, MEM, SCRATCH),
|
base_reg_class (VOIDmode, MEM, SCRATCH),
|
address_mode,
|
address_mode,
|
VOIDmode, 0, 0, i, RELOAD_FOR_INPUT);
|
VOIDmode, 0, 0, i, RELOAD_FOR_INPUT);
|
rld[operand_reloadnum[i]].inc
|
rld[operand_reloadnum[i]].inc
|
= GET_MODE_SIZE (GET_MODE (recog_data.operand[i]));
|
= GET_MODE_SIZE (GET_MODE (recog_data.operand[i]));
|
|
|
/* If this operand is an output, we will have made any
|
/* If this operand is an output, we will have made any
|
reloads for its address as RELOAD_FOR_OUTPUT_ADDRESS, but
|
reloads for its address as RELOAD_FOR_OUTPUT_ADDRESS, but
|
now we are treating part of the operand as an input, so
|
now we are treating part of the operand as an input, so
|
we must change these to RELOAD_FOR_INPUT_ADDRESS. */
|
we must change these to RELOAD_FOR_INPUT_ADDRESS. */
|
|
|
if (modified[i] == RELOAD_WRITE)
|
if (modified[i] == RELOAD_WRITE)
|
{
|
{
|
for (j = 0; j < n_reloads; j++)
|
for (j = 0; j < n_reloads; j++)
|
{
|
{
|
if (rld[j].opnum == i)
|
if (rld[j].opnum == i)
|
{
|
{
|
if (rld[j].when_needed == RELOAD_FOR_OUTPUT_ADDRESS)
|
if (rld[j].when_needed == RELOAD_FOR_OUTPUT_ADDRESS)
|
rld[j].when_needed = RELOAD_FOR_INPUT_ADDRESS;
|
rld[j].when_needed = RELOAD_FOR_INPUT_ADDRESS;
|
else if (rld[j].when_needed
|
else if (rld[j].when_needed
|
== RELOAD_FOR_OUTADDR_ADDRESS)
|
== RELOAD_FOR_OUTADDR_ADDRESS)
|
rld[j].when_needed = RELOAD_FOR_INPADDR_ADDRESS;
|
rld[j].when_needed = RELOAD_FOR_INPADDR_ADDRESS;
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
else if (goal_alternative_matched[i] == -1)
|
else if (goal_alternative_matched[i] == -1)
|
{
|
{
|
operand_reloadnum[i]
|
operand_reloadnum[i]
|
= push_reload ((modified[i] != RELOAD_WRITE
|
= push_reload ((modified[i] != RELOAD_WRITE
|
? recog_data.operand[i] : 0),
|
? recog_data.operand[i] : 0),
|
(modified[i] != RELOAD_READ
|
(modified[i] != RELOAD_READ
|
? recog_data.operand[i] : 0),
|
? recog_data.operand[i] : 0),
|
(modified[i] != RELOAD_WRITE
|
(modified[i] != RELOAD_WRITE
|
? recog_data.operand_loc[i] : 0),
|
? recog_data.operand_loc[i] : 0),
|
(modified[i] != RELOAD_READ
|
(modified[i] != RELOAD_READ
|
? recog_data.operand_loc[i] : 0),
|
? recog_data.operand_loc[i] : 0),
|
(enum reg_class) goal_alternative[i],
|
(enum reg_class) goal_alternative[i],
|
(modified[i] == RELOAD_WRITE
|
(modified[i] == RELOAD_WRITE
|
? VOIDmode : operand_mode[i]),
|
? VOIDmode : operand_mode[i]),
|
(modified[i] == RELOAD_READ
|
(modified[i] == RELOAD_READ
|
? VOIDmode : operand_mode[i]),
|
? VOIDmode : operand_mode[i]),
|
(insn_code_number < 0 ? 0
|
(insn_code_number < 0 ? 0
|
: insn_data[insn_code_number].operand[i].strict_low),
|
: insn_data[insn_code_number].operand[i].strict_low),
|
0, i, operand_type[i]);
|
0, i, operand_type[i]);
|
}
|
}
|
/* In a matching pair of operands, one must be input only
|
/* In a matching pair of operands, one must be input only
|
and the other must be output only.
|
and the other must be output only.
|
Pass the input operand as IN and the other as OUT. */
|
Pass the input operand as IN and the other as OUT. */
|
else if (modified[i] == RELOAD_READ
|
else if (modified[i] == RELOAD_READ
|
&& modified[goal_alternative_matched[i]] == RELOAD_WRITE)
|
&& modified[goal_alternative_matched[i]] == RELOAD_WRITE)
|
{
|
{
|
operand_reloadnum[i]
|
operand_reloadnum[i]
|
= push_reload (recog_data.operand[i],
|
= push_reload (recog_data.operand[i],
|
recog_data.operand[goal_alternative_matched[i]],
|
recog_data.operand[goal_alternative_matched[i]],
|
recog_data.operand_loc[i],
|
recog_data.operand_loc[i],
|
recog_data.operand_loc[goal_alternative_matched[i]],
|
recog_data.operand_loc[goal_alternative_matched[i]],
|
(enum reg_class) goal_alternative[i],
|
(enum reg_class) goal_alternative[i],
|
operand_mode[i],
|
operand_mode[i],
|
operand_mode[goal_alternative_matched[i]],
|
operand_mode[goal_alternative_matched[i]],
|
0, 0, i, RELOAD_OTHER);
|
0, 0, i, RELOAD_OTHER);
|
operand_reloadnum[goal_alternative_matched[i]] = output_reloadnum;
|
operand_reloadnum[goal_alternative_matched[i]] = output_reloadnum;
|
}
|
}
|
else if (modified[i] == RELOAD_WRITE
|
else if (modified[i] == RELOAD_WRITE
|
&& modified[goal_alternative_matched[i]] == RELOAD_READ)
|
&& modified[goal_alternative_matched[i]] == RELOAD_READ)
|
{
|
{
|
operand_reloadnum[goal_alternative_matched[i]]
|
operand_reloadnum[goal_alternative_matched[i]]
|
= push_reload (recog_data.operand[goal_alternative_matched[i]],
|
= push_reload (recog_data.operand[goal_alternative_matched[i]],
|
recog_data.operand[i],
|
recog_data.operand[i],
|
recog_data.operand_loc[goal_alternative_matched[i]],
|
recog_data.operand_loc[goal_alternative_matched[i]],
|
recog_data.operand_loc[i],
|
recog_data.operand_loc[i],
|
(enum reg_class) goal_alternative[i],
|
(enum reg_class) goal_alternative[i],
|
operand_mode[goal_alternative_matched[i]],
|
operand_mode[goal_alternative_matched[i]],
|
operand_mode[i],
|
operand_mode[i],
|
0, 0, i, RELOAD_OTHER);
|
0, 0, i, RELOAD_OTHER);
|
operand_reloadnum[i] = output_reloadnum;
|
operand_reloadnum[i] = output_reloadnum;
|
}
|
}
|
else
|
else
|
{
|
{
|
gcc_assert (insn_code_number < 0);
|
gcc_assert (insn_code_number < 0);
|
error_for_asm (insn, "inconsistent operand constraints "
|
error_for_asm (insn, "inconsistent operand constraints "
|
"in an %<asm%>");
|
"in an %<asm%>");
|
/* Avoid further trouble with this insn. */
|
/* Avoid further trouble with this insn. */
|
PATTERN (insn) = gen_rtx_USE (VOIDmode, const0_rtx);
|
PATTERN (insn) = gen_rtx_USE (VOIDmode, const0_rtx);
|
n_reloads = 0;
|
n_reloads = 0;
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
else if (goal_alternative_matched[i] < 0
|
else if (goal_alternative_matched[i] < 0
|
&& goal_alternative_matches[i] < 0
|
&& goal_alternative_matches[i] < 0
|
&& address_operand_reloaded[i] != 1
|
&& address_operand_reloaded[i] != 1
|
&& optimize)
|
&& optimize)
|
{
|
{
|
/* For each non-matching operand that's a MEM or a pseudo-register
|
/* For each non-matching operand that's a MEM or a pseudo-register
|
that didn't get a hard register, make an optional reload.
|
that didn't get a hard register, make an optional reload.
|
This may get done even if the insn needs no reloads otherwise. */
|
This may get done even if the insn needs no reloads otherwise. */
|
|
|
rtx operand = recog_data.operand[i];
|
rtx operand = recog_data.operand[i];
|
|
|
while (GET_CODE (operand) == SUBREG)
|
while (GET_CODE (operand) == SUBREG)
|
operand = SUBREG_REG (operand);
|
operand = SUBREG_REG (operand);
|
if ((MEM_P (operand)
|
if ((MEM_P (operand)
|
|| (REG_P (operand)
|
|| (REG_P (operand)
|
&& REGNO (operand) >= FIRST_PSEUDO_REGISTER))
|
&& REGNO (operand) >= FIRST_PSEUDO_REGISTER))
|
/* If this is only for an output, the optional reload would not
|
/* If this is only for an output, the optional reload would not
|
actually cause us to use a register now, just note that
|
actually cause us to use a register now, just note that
|
something is stored here. */
|
something is stored here. */
|
&& ((enum reg_class) goal_alternative[i] != NO_REGS
|
&& ((enum reg_class) goal_alternative[i] != NO_REGS
|
|| modified[i] == RELOAD_WRITE)
|
|| modified[i] == RELOAD_WRITE)
|
&& ! no_input_reloads
|
&& ! no_input_reloads
|
/* An optional output reload might allow to delete INSN later.
|
/* An optional output reload might allow to delete INSN later.
|
We mustn't make in-out reloads on insns that are not permitted
|
We mustn't make in-out reloads on insns that are not permitted
|
output reloads.
|
output reloads.
|
If this is an asm, we can't delete it; we must not even call
|
If this is an asm, we can't delete it; we must not even call
|
push_reload for an optional output reload in this case,
|
push_reload for an optional output reload in this case,
|
because we can't be sure that the constraint allows a register,
|
because we can't be sure that the constraint allows a register,
|
and push_reload verifies the constraints for asms. */
|
and push_reload verifies the constraints for asms. */
|
&& (modified[i] == RELOAD_READ
|
&& (modified[i] == RELOAD_READ
|
|| (! no_output_reloads && ! this_insn_is_asm)))
|
|| (! no_output_reloads && ! this_insn_is_asm)))
|
operand_reloadnum[i]
|
operand_reloadnum[i]
|
= push_reload ((modified[i] != RELOAD_WRITE
|
= push_reload ((modified[i] != RELOAD_WRITE
|
? recog_data.operand[i] : 0),
|
? recog_data.operand[i] : 0),
|
(modified[i] != RELOAD_READ
|
(modified[i] != RELOAD_READ
|
? recog_data.operand[i] : 0),
|
? recog_data.operand[i] : 0),
|
(modified[i] != RELOAD_WRITE
|
(modified[i] != RELOAD_WRITE
|
? recog_data.operand_loc[i] : 0),
|
? recog_data.operand_loc[i] : 0),
|
(modified[i] != RELOAD_READ
|
(modified[i] != RELOAD_READ
|
? recog_data.operand_loc[i] : 0),
|
? recog_data.operand_loc[i] : 0),
|
(enum reg_class) goal_alternative[i],
|
(enum reg_class) goal_alternative[i],
|
(modified[i] == RELOAD_WRITE
|
(modified[i] == RELOAD_WRITE
|
? VOIDmode : operand_mode[i]),
|
? VOIDmode : operand_mode[i]),
|
(modified[i] == RELOAD_READ
|
(modified[i] == RELOAD_READ
|
? VOIDmode : operand_mode[i]),
|
? VOIDmode : operand_mode[i]),
|
(insn_code_number < 0 ? 0
|
(insn_code_number < 0 ? 0
|
: insn_data[insn_code_number].operand[i].strict_low),
|
: insn_data[insn_code_number].operand[i].strict_low),
|
1, i, operand_type[i]);
|
1, i, operand_type[i]);
|
/* If a memory reference remains (either as a MEM or a pseudo that
|
/* If a memory reference remains (either as a MEM or a pseudo that
|
did not get a hard register), yet we can't make an optional
|
did not get a hard register), yet we can't make an optional
|
reload, check if this is actually a pseudo register reference;
|
reload, check if this is actually a pseudo register reference;
|
we then need to emit a USE and/or a CLOBBER so that reload
|
we then need to emit a USE and/or a CLOBBER so that reload
|
inheritance will do the right thing. */
|
inheritance will do the right thing. */
|
else if (replace
|
else if (replace
|
&& (MEM_P (operand)
|
&& (MEM_P (operand)
|
|| (REG_P (operand)
|
|| (REG_P (operand)
|
&& REGNO (operand) >= FIRST_PSEUDO_REGISTER
|
&& REGNO (operand) >= FIRST_PSEUDO_REGISTER
|
&& reg_renumber [REGNO (operand)] < 0)))
|
&& reg_renumber [REGNO (operand)] < 0)))
|
{
|
{
|
operand = *recog_data.operand_loc[i];
|
operand = *recog_data.operand_loc[i];
|
|
|
while (GET_CODE (operand) == SUBREG)
|
while (GET_CODE (operand) == SUBREG)
|
operand = SUBREG_REG (operand);
|
operand = SUBREG_REG (operand);
|
if (REG_P (operand))
|
if (REG_P (operand))
|
{
|
{
|
if (modified[i] != RELOAD_WRITE)
|
if (modified[i] != RELOAD_WRITE)
|
/* We mark the USE with QImode so that we recognize
|
/* We mark the USE with QImode so that we recognize
|
it as one that can be safely deleted at the end
|
it as one that can be safely deleted at the end
|
of reload. */
|
of reload. */
|
PUT_MODE (emit_insn_before (gen_rtx_USE (VOIDmode, operand),
|
PUT_MODE (emit_insn_before (gen_rtx_USE (VOIDmode, operand),
|
insn), QImode);
|
insn), QImode);
|
if (modified[i] != RELOAD_READ)
|
if (modified[i] != RELOAD_READ)
|
emit_insn_after (gen_rtx_CLOBBER (VOIDmode, operand), insn);
|
emit_insn_after (gen_rtx_CLOBBER (VOIDmode, operand), insn);
|
}
|
}
|
}
|
}
|
}
|
}
|
else if (goal_alternative_matches[i] >= 0
|
else if (goal_alternative_matches[i] >= 0
|
&& goal_alternative_win[goal_alternative_matches[i]]
|
&& goal_alternative_win[goal_alternative_matches[i]]
|
&& modified[i] == RELOAD_READ
|
&& modified[i] == RELOAD_READ
|
&& modified[goal_alternative_matches[i]] == RELOAD_WRITE
|
&& modified[goal_alternative_matches[i]] == RELOAD_WRITE
|
&& ! no_input_reloads && ! no_output_reloads
|
&& ! no_input_reloads && ! no_output_reloads
|
&& optimize)
|
&& optimize)
|
{
|
{
|
/* Similarly, make an optional reload for a pair of matching
|
/* Similarly, make an optional reload for a pair of matching
|
objects that are in MEM or a pseudo that didn't get a hard reg. */
|
objects that are in MEM or a pseudo that didn't get a hard reg. */
|
|
|
rtx operand = recog_data.operand[i];
|
rtx operand = recog_data.operand[i];
|
|
|
while (GET_CODE (operand) == SUBREG)
|
while (GET_CODE (operand) == SUBREG)
|
operand = SUBREG_REG (operand);
|
operand = SUBREG_REG (operand);
|
if ((MEM_P (operand)
|
if ((MEM_P (operand)
|
|| (REG_P (operand)
|
|| (REG_P (operand)
|
&& REGNO (operand) >= FIRST_PSEUDO_REGISTER))
|
&& REGNO (operand) >= FIRST_PSEUDO_REGISTER))
|
&& ((enum reg_class) goal_alternative[goal_alternative_matches[i]]
|
&& ((enum reg_class) goal_alternative[goal_alternative_matches[i]]
|
!= NO_REGS))
|
!= NO_REGS))
|
operand_reloadnum[i] = operand_reloadnum[goal_alternative_matches[i]]
|
operand_reloadnum[i] = operand_reloadnum[goal_alternative_matches[i]]
|
= push_reload (recog_data.operand[goal_alternative_matches[i]],
|
= push_reload (recog_data.operand[goal_alternative_matches[i]],
|
recog_data.operand[i],
|
recog_data.operand[i],
|
recog_data.operand_loc[goal_alternative_matches[i]],
|
recog_data.operand_loc[goal_alternative_matches[i]],
|
recog_data.operand_loc[i],
|
recog_data.operand_loc[i],
|
(enum reg_class) goal_alternative[goal_alternative_matches[i]],
|
(enum reg_class) goal_alternative[goal_alternative_matches[i]],
|
operand_mode[goal_alternative_matches[i]],
|
operand_mode[goal_alternative_matches[i]],
|
operand_mode[i],
|
operand_mode[i],
|
0, 1, goal_alternative_matches[i], RELOAD_OTHER);
|
0, 1, goal_alternative_matches[i], RELOAD_OTHER);
|
}
|
}
|
|
|
/* Perform whatever substitutions on the operands we are supposed
|
/* Perform whatever substitutions on the operands we are supposed
|
to make due to commutativity or replacement of registers
|
to make due to commutativity or replacement of registers
|
with equivalent constants or memory slots. */
|
with equivalent constants or memory slots. */
|
|
|
for (i = 0; i < noperands; i++)
|
for (i = 0; i < noperands; i++)
|
{
|
{
|
/* We only do this on the last pass through reload, because it is
|
/* We only do this on the last pass through reload, because it is
|
possible for some data (like reg_equiv_address) to be changed during
|
possible for some data (like reg_equiv_address) to be changed during
|
later passes. Moreover, we lose the opportunity to get a useful
|
later passes. Moreover, we lose the opportunity to get a useful
|
reload_{in,out}_reg when we do these replacements. */
|
reload_{in,out}_reg when we do these replacements. */
|
|
|
if (replace)
|
if (replace)
|
{
|
{
|
rtx substitution = substed_operand[i];
|
rtx substitution = substed_operand[i];
|
|
|
*recog_data.operand_loc[i] = substitution;
|
*recog_data.operand_loc[i] = substitution;
|
|
|
/* If we're replacing an operand with a LABEL_REF, we need
|
/* If we're replacing an operand with a LABEL_REF, we need
|
to make sure that there's a REG_LABEL note attached to
|
to make sure that there's a REG_LABEL note attached to
|
this instruction. */
|
this instruction. */
|
if (!JUMP_P (insn)
|
if (!JUMP_P (insn)
|
&& GET_CODE (substitution) == LABEL_REF
|
&& GET_CODE (substitution) == LABEL_REF
|
&& !find_reg_note (insn, REG_LABEL, XEXP (substitution, 0)))
|
&& !find_reg_note (insn, REG_LABEL, XEXP (substitution, 0)))
|
REG_NOTES (insn) = gen_rtx_INSN_LIST (REG_LABEL,
|
REG_NOTES (insn) = gen_rtx_INSN_LIST (REG_LABEL,
|
XEXP (substitution, 0),
|
XEXP (substitution, 0),
|
REG_NOTES (insn));
|
REG_NOTES (insn));
|
}
|
}
|
else
|
else
|
retval |= (substed_operand[i] != *recog_data.operand_loc[i]);
|
retval |= (substed_operand[i] != *recog_data.operand_loc[i]);
|
}
|
}
|
|
|
/* If this insn pattern contains any MATCH_DUP's, make sure that
|
/* If this insn pattern contains any MATCH_DUP's, make sure that
|
they will be substituted if the operands they match are substituted.
|
they will be substituted if the operands they match are substituted.
|
Also do now any substitutions we already did on the operands.
|
Also do now any substitutions we already did on the operands.
|
|
|
Don't do this if we aren't making replacements because we might be
|
Don't do this if we aren't making replacements because we might be
|
propagating things allocated by frame pointer elimination into places
|
propagating things allocated by frame pointer elimination into places
|
it doesn't expect. */
|
it doesn't expect. */
|
|
|
if (insn_code_number >= 0 && replace)
|
if (insn_code_number >= 0 && replace)
|
for (i = insn_data[insn_code_number].n_dups - 1; i >= 0; i--)
|
for (i = insn_data[insn_code_number].n_dups - 1; i >= 0; i--)
|
{
|
{
|
int opno = recog_data.dup_num[i];
|
int opno = recog_data.dup_num[i];
|
*recog_data.dup_loc[i] = *recog_data.operand_loc[opno];
|
*recog_data.dup_loc[i] = *recog_data.operand_loc[opno];
|
dup_replacements (recog_data.dup_loc[i], recog_data.operand_loc[opno]);
|
dup_replacements (recog_data.dup_loc[i], recog_data.operand_loc[opno]);
|
}
|
}
|
|
|
#if 0
|
#if 0
|
/* This loses because reloading of prior insns can invalidate the equivalence
|
/* This loses because reloading of prior insns can invalidate the equivalence
|
(or at least find_equiv_reg isn't smart enough to find it any more),
|
(or at least find_equiv_reg isn't smart enough to find it any more),
|
causing this insn to need more reload regs than it needed before.
|
causing this insn to need more reload regs than it needed before.
|
It may be too late to make the reload regs available.
|
It may be too late to make the reload regs available.
|
Now this optimization is done safely in choose_reload_regs. */
|
Now this optimization is done safely in choose_reload_regs. */
|
|
|
/* For each reload of a reg into some other class of reg,
|
/* For each reload of a reg into some other class of reg,
|
search for an existing equivalent reg (same value now) in the right class.
|
search for an existing equivalent reg (same value now) in the right class.
|
We can use it as long as we don't need to change its contents. */
|
We can use it as long as we don't need to change its contents. */
|
for (i = 0; i < n_reloads; i++)
|
for (i = 0; i < n_reloads; i++)
|
if (rld[i].reg_rtx == 0
|
if (rld[i].reg_rtx == 0
|
&& rld[i].in != 0
|
&& rld[i].in != 0
|
&& REG_P (rld[i].in)
|
&& REG_P (rld[i].in)
|
&& rld[i].out == 0)
|
&& rld[i].out == 0)
|
{
|
{
|
rld[i].reg_rtx
|
rld[i].reg_rtx
|
= find_equiv_reg (rld[i].in, insn, rld[i].class, -1,
|
= find_equiv_reg (rld[i].in, insn, rld[i].class, -1,
|
static_reload_reg_p, 0, rld[i].inmode);
|
static_reload_reg_p, 0, rld[i].inmode);
|
/* Prevent generation of insn to load the value
|
/* Prevent generation of insn to load the value
|
because the one we found already has the value. */
|
because the one we found already has the value. */
|
if (rld[i].reg_rtx)
|
if (rld[i].reg_rtx)
|
rld[i].in = rld[i].reg_rtx;
|
rld[i].in = rld[i].reg_rtx;
|
}
|
}
|
#endif
|
#endif
|
|
|
/* If we detected error and replaced asm instruction by USE, forget about the
|
/* If we detected error and replaced asm instruction by USE, forget about the
|
reloads. */
|
reloads. */
|
if (GET_CODE (PATTERN (insn)) == USE
|
if (GET_CODE (PATTERN (insn)) == USE
|
&& GET_CODE (XEXP (PATTERN (insn), 0)) == CONST_INT)
|
&& GET_CODE (XEXP (PATTERN (insn), 0)) == CONST_INT)
|
n_reloads = 0;
|
n_reloads = 0;
|
|
|
/* Perhaps an output reload can be combined with another
|
/* Perhaps an output reload can be combined with another
|
to reduce needs by one. */
|
to reduce needs by one. */
|
if (!goal_earlyclobber)
|
if (!goal_earlyclobber)
|
combine_reloads ();
|
combine_reloads ();
|
|
|
/* If we have a pair of reloads for parts of an address, they are reloading
|
/* If we have a pair of reloads for parts of an address, they are reloading
|
the same object, the operands themselves were not reloaded, and they
|
the same object, the operands themselves were not reloaded, and they
|
are for two operands that are supposed to match, merge the reloads and
|
are for two operands that are supposed to match, merge the reloads and
|
change the type of the surviving reload to RELOAD_FOR_OPERAND_ADDRESS. */
|
change the type of the surviving reload to RELOAD_FOR_OPERAND_ADDRESS. */
|
|
|
for (i = 0; i < n_reloads; i++)
|
for (i = 0; i < n_reloads; i++)
|
{
|
{
|
int k;
|
int k;
|
|
|
for (j = i + 1; j < n_reloads; j++)
|
for (j = i + 1; j < n_reloads; j++)
|
if ((rld[i].when_needed == RELOAD_FOR_INPUT_ADDRESS
|
if ((rld[i].when_needed == RELOAD_FOR_INPUT_ADDRESS
|
|| rld[i].when_needed == RELOAD_FOR_OUTPUT_ADDRESS
|
|| rld[i].when_needed == RELOAD_FOR_OUTPUT_ADDRESS
|
|| rld[i].when_needed == RELOAD_FOR_INPADDR_ADDRESS
|
|| rld[i].when_needed == RELOAD_FOR_INPADDR_ADDRESS
|
|| rld[i].when_needed == RELOAD_FOR_OUTADDR_ADDRESS)
|
|| rld[i].when_needed == RELOAD_FOR_OUTADDR_ADDRESS)
|
&& (rld[j].when_needed == RELOAD_FOR_INPUT_ADDRESS
|
&& (rld[j].when_needed == RELOAD_FOR_INPUT_ADDRESS
|
|| rld[j].when_needed == RELOAD_FOR_OUTPUT_ADDRESS
|
|| rld[j].when_needed == RELOAD_FOR_OUTPUT_ADDRESS
|
|| rld[j].when_needed == RELOAD_FOR_INPADDR_ADDRESS
|
|| rld[j].when_needed == RELOAD_FOR_INPADDR_ADDRESS
|
|| rld[j].when_needed == RELOAD_FOR_OUTADDR_ADDRESS)
|
|| rld[j].when_needed == RELOAD_FOR_OUTADDR_ADDRESS)
|
&& rtx_equal_p (rld[i].in, rld[j].in)
|
&& rtx_equal_p (rld[i].in, rld[j].in)
|
&& (operand_reloadnum[rld[i].opnum] < 0
|
&& (operand_reloadnum[rld[i].opnum] < 0
|
|| rld[operand_reloadnum[rld[i].opnum]].optional)
|
|| rld[operand_reloadnum[rld[i].opnum]].optional)
|
&& (operand_reloadnum[rld[j].opnum] < 0
|
&& (operand_reloadnum[rld[j].opnum] < 0
|
|| rld[operand_reloadnum[rld[j].opnum]].optional)
|
|| rld[operand_reloadnum[rld[j].opnum]].optional)
|
&& (goal_alternative_matches[rld[i].opnum] == rld[j].opnum
|
&& (goal_alternative_matches[rld[i].opnum] == rld[j].opnum
|
|| (goal_alternative_matches[rld[j].opnum]
|
|| (goal_alternative_matches[rld[j].opnum]
|
== rld[i].opnum)))
|
== rld[i].opnum)))
|
{
|
{
|
for (k = 0; k < n_replacements; k++)
|
for (k = 0; k < n_replacements; k++)
|
if (replacements[k].what == j)
|
if (replacements[k].what == j)
|
replacements[k].what = i;
|
replacements[k].what = i;
|
|
|
if (rld[i].when_needed == RELOAD_FOR_INPADDR_ADDRESS
|
if (rld[i].when_needed == RELOAD_FOR_INPADDR_ADDRESS
|
|| rld[i].when_needed == RELOAD_FOR_OUTADDR_ADDRESS)
|
|| rld[i].when_needed == RELOAD_FOR_OUTADDR_ADDRESS)
|
rld[i].when_needed = RELOAD_FOR_OPADDR_ADDR;
|
rld[i].when_needed = RELOAD_FOR_OPADDR_ADDR;
|
else
|
else
|
rld[i].when_needed = RELOAD_FOR_OPERAND_ADDRESS;
|
rld[i].when_needed = RELOAD_FOR_OPERAND_ADDRESS;
|
rld[j].in = 0;
|
rld[j].in = 0;
|
}
|
}
|
}
|
}
|
|
|
/* Scan all the reloads and update their type.
|
/* Scan all the reloads and update their type.
|
If a reload is for the address of an operand and we didn't reload
|
If a reload is for the address of an operand and we didn't reload
|
that operand, change the type. Similarly, change the operand number
|
that operand, change the type. Similarly, change the operand number
|
of a reload when two operands match. If a reload is optional, treat it
|
of a reload when two operands match. If a reload is optional, treat it
|
as though the operand isn't reloaded.
|
as though the operand isn't reloaded.
|
|
|
??? This latter case is somewhat odd because if we do the optional
|
??? This latter case is somewhat odd because if we do the optional
|
reload, it means the object is hanging around. Thus we need only
|
reload, it means the object is hanging around. Thus we need only
|
do the address reload if the optional reload was NOT done.
|
do the address reload if the optional reload was NOT done.
|
|
|
Change secondary reloads to be the address type of their operand, not
|
Change secondary reloads to be the address type of their operand, not
|
the normal type.
|
the normal type.
|
|
|
If an operand's reload is now RELOAD_OTHER, change any
|
If an operand's reload is now RELOAD_OTHER, change any
|
RELOAD_FOR_INPUT_ADDRESS reloads of that operand to
|
RELOAD_FOR_INPUT_ADDRESS reloads of that operand to
|
RELOAD_FOR_OTHER_ADDRESS. */
|
RELOAD_FOR_OTHER_ADDRESS. */
|
|
|
for (i = 0; i < n_reloads; i++)
|
for (i = 0; i < n_reloads; i++)
|
{
|
{
|
if (rld[i].secondary_p
|
if (rld[i].secondary_p
|
&& rld[i].when_needed == operand_type[rld[i].opnum])
|
&& rld[i].when_needed == operand_type[rld[i].opnum])
|
rld[i].when_needed = address_type[rld[i].opnum];
|
rld[i].when_needed = address_type[rld[i].opnum];
|
|
|
if ((rld[i].when_needed == RELOAD_FOR_INPUT_ADDRESS
|
if ((rld[i].when_needed == RELOAD_FOR_INPUT_ADDRESS
|
|| rld[i].when_needed == RELOAD_FOR_OUTPUT_ADDRESS
|
|| rld[i].when_needed == RELOAD_FOR_OUTPUT_ADDRESS
|
|| rld[i].when_needed == RELOAD_FOR_INPADDR_ADDRESS
|
|| rld[i].when_needed == RELOAD_FOR_INPADDR_ADDRESS
|
|| rld[i].when_needed == RELOAD_FOR_OUTADDR_ADDRESS)
|
|| rld[i].when_needed == RELOAD_FOR_OUTADDR_ADDRESS)
|
&& (operand_reloadnum[rld[i].opnum] < 0
|
&& (operand_reloadnum[rld[i].opnum] < 0
|
|| rld[operand_reloadnum[rld[i].opnum]].optional))
|
|| rld[operand_reloadnum[rld[i].opnum]].optional))
|
{
|
{
|
/* If we have a secondary reload to go along with this reload,
|
/* If we have a secondary reload to go along with this reload,
|
change its type to RELOAD_FOR_OPADDR_ADDR. */
|
change its type to RELOAD_FOR_OPADDR_ADDR. */
|
|
|
if ((rld[i].when_needed == RELOAD_FOR_INPUT_ADDRESS
|
if ((rld[i].when_needed == RELOAD_FOR_INPUT_ADDRESS
|
|| rld[i].when_needed == RELOAD_FOR_INPADDR_ADDRESS)
|
|| rld[i].when_needed == RELOAD_FOR_INPADDR_ADDRESS)
|
&& rld[i].secondary_in_reload != -1)
|
&& rld[i].secondary_in_reload != -1)
|
{
|
{
|
int secondary_in_reload = rld[i].secondary_in_reload;
|
int secondary_in_reload = rld[i].secondary_in_reload;
|
|
|
rld[secondary_in_reload].when_needed = RELOAD_FOR_OPADDR_ADDR;
|
rld[secondary_in_reload].when_needed = RELOAD_FOR_OPADDR_ADDR;
|
|
|
/* If there's a tertiary reload we have to change it also. */
|
/* If there's a tertiary reload we have to change it also. */
|
if (secondary_in_reload > 0
|
if (secondary_in_reload > 0
|
&& rld[secondary_in_reload].secondary_in_reload != -1)
|
&& rld[secondary_in_reload].secondary_in_reload != -1)
|
rld[rld[secondary_in_reload].secondary_in_reload].when_needed
|
rld[rld[secondary_in_reload].secondary_in_reload].when_needed
|
= RELOAD_FOR_OPADDR_ADDR;
|
= RELOAD_FOR_OPADDR_ADDR;
|
}
|
}
|
|
|
if ((rld[i].when_needed == RELOAD_FOR_OUTPUT_ADDRESS
|
if ((rld[i].when_needed == RELOAD_FOR_OUTPUT_ADDRESS
|
|| rld[i].when_needed == RELOAD_FOR_OUTADDR_ADDRESS)
|
|| rld[i].when_needed == RELOAD_FOR_OUTADDR_ADDRESS)
|
&& rld[i].secondary_out_reload != -1)
|
&& rld[i].secondary_out_reload != -1)
|
{
|
{
|
int secondary_out_reload = rld[i].secondary_out_reload;
|
int secondary_out_reload = rld[i].secondary_out_reload;
|
|
|
rld[secondary_out_reload].when_needed = RELOAD_FOR_OPADDR_ADDR;
|
rld[secondary_out_reload].when_needed = RELOAD_FOR_OPADDR_ADDR;
|
|
|
/* If there's a tertiary reload we have to change it also. */
|
/* If there's a tertiary reload we have to change it also. */
|
if (secondary_out_reload
|
if (secondary_out_reload
|
&& rld[secondary_out_reload].secondary_out_reload != -1)
|
&& rld[secondary_out_reload].secondary_out_reload != -1)
|
rld[rld[secondary_out_reload].secondary_out_reload].when_needed
|
rld[rld[secondary_out_reload].secondary_out_reload].when_needed
|
= RELOAD_FOR_OPADDR_ADDR;
|
= RELOAD_FOR_OPADDR_ADDR;
|
}
|
}
|
|
|
if (rld[i].when_needed == RELOAD_FOR_INPADDR_ADDRESS
|
if (rld[i].when_needed == RELOAD_FOR_INPADDR_ADDRESS
|
|| rld[i].when_needed == RELOAD_FOR_OUTADDR_ADDRESS)
|
|| rld[i].when_needed == RELOAD_FOR_OUTADDR_ADDRESS)
|
rld[i].when_needed = RELOAD_FOR_OPADDR_ADDR;
|
rld[i].when_needed = RELOAD_FOR_OPADDR_ADDR;
|
else
|
else
|
rld[i].when_needed = RELOAD_FOR_OPERAND_ADDRESS;
|
rld[i].when_needed = RELOAD_FOR_OPERAND_ADDRESS;
|
}
|
}
|
|
|
if ((rld[i].when_needed == RELOAD_FOR_INPUT_ADDRESS
|
if ((rld[i].when_needed == RELOAD_FOR_INPUT_ADDRESS
|
|| rld[i].when_needed == RELOAD_FOR_INPADDR_ADDRESS)
|
|| rld[i].when_needed == RELOAD_FOR_INPADDR_ADDRESS)
|
&& operand_reloadnum[rld[i].opnum] >= 0
|
&& operand_reloadnum[rld[i].opnum] >= 0
|
&& (rld[operand_reloadnum[rld[i].opnum]].when_needed
|
&& (rld[operand_reloadnum[rld[i].opnum]].when_needed
|
== RELOAD_OTHER))
|
== RELOAD_OTHER))
|
rld[i].when_needed = RELOAD_FOR_OTHER_ADDRESS;
|
rld[i].when_needed = RELOAD_FOR_OTHER_ADDRESS;
|
|
|
if (goal_alternative_matches[rld[i].opnum] >= 0)
|
if (goal_alternative_matches[rld[i].opnum] >= 0)
|
rld[i].opnum = goal_alternative_matches[rld[i].opnum];
|
rld[i].opnum = goal_alternative_matches[rld[i].opnum];
|
}
|
}
|
|
|
/* Scan all the reloads, and check for RELOAD_FOR_OPERAND_ADDRESS reloads.
|
/* Scan all the reloads, and check for RELOAD_FOR_OPERAND_ADDRESS reloads.
|
If we have more than one, then convert all RELOAD_FOR_OPADDR_ADDR
|
If we have more than one, then convert all RELOAD_FOR_OPADDR_ADDR
|
reloads to RELOAD_FOR_OPERAND_ADDRESS reloads.
|
reloads to RELOAD_FOR_OPERAND_ADDRESS reloads.
|
|
|
choose_reload_regs assumes that RELOAD_FOR_OPADDR_ADDR reloads never
|
choose_reload_regs assumes that RELOAD_FOR_OPADDR_ADDR reloads never
|
conflict with RELOAD_FOR_OPERAND_ADDRESS reloads. This is true for a
|
conflict with RELOAD_FOR_OPERAND_ADDRESS reloads. This is true for a
|
single pair of RELOAD_FOR_OPADDR_ADDR/RELOAD_FOR_OPERAND_ADDRESS reloads.
|
single pair of RELOAD_FOR_OPADDR_ADDR/RELOAD_FOR_OPERAND_ADDRESS reloads.
|
However, if there is more than one RELOAD_FOR_OPERAND_ADDRESS reload,
|
However, if there is more than one RELOAD_FOR_OPERAND_ADDRESS reload,
|
then a RELOAD_FOR_OPADDR_ADDR reload conflicts with all
|
then a RELOAD_FOR_OPADDR_ADDR reload conflicts with all
|
RELOAD_FOR_OPERAND_ADDRESS reloads other than the one that uses it.
|
RELOAD_FOR_OPERAND_ADDRESS reloads other than the one that uses it.
|
This is complicated by the fact that a single operand can have more
|
This is complicated by the fact that a single operand can have more
|
than one RELOAD_FOR_OPERAND_ADDRESS reload. It is very difficult to fix
|
than one RELOAD_FOR_OPERAND_ADDRESS reload. It is very difficult to fix
|
choose_reload_regs without affecting code quality, and cases that
|
choose_reload_regs without affecting code quality, and cases that
|
actually fail are extremely rare, so it turns out to be better to fix
|
actually fail are extremely rare, so it turns out to be better to fix
|
the problem here by not generating cases that choose_reload_regs will
|
the problem here by not generating cases that choose_reload_regs will
|
fail for. */
|
fail for. */
|
/* There is a similar problem with RELOAD_FOR_INPUT_ADDRESS /
|
/* There is a similar problem with RELOAD_FOR_INPUT_ADDRESS /
|
RELOAD_FOR_OUTPUT_ADDRESS when there is more than one of a kind for
|
RELOAD_FOR_OUTPUT_ADDRESS when there is more than one of a kind for
|
a single operand.
|
a single operand.
|
We can reduce the register pressure by exploiting that a
|
We can reduce the register pressure by exploiting that a
|
RELOAD_FOR_X_ADDR_ADDR that precedes all RELOAD_FOR_X_ADDRESS reloads
|
RELOAD_FOR_X_ADDR_ADDR that precedes all RELOAD_FOR_X_ADDRESS reloads
|
does not conflict with any of them, if it is only used for the first of
|
does not conflict with any of them, if it is only used for the first of
|
the RELOAD_FOR_X_ADDRESS reloads. */
|
the RELOAD_FOR_X_ADDRESS reloads. */
|
{
|
{
|
int first_op_addr_num = -2;
|
int first_op_addr_num = -2;
|
int first_inpaddr_num[MAX_RECOG_OPERANDS];
|
int first_inpaddr_num[MAX_RECOG_OPERANDS];
|
int first_outpaddr_num[MAX_RECOG_OPERANDS];
|
int first_outpaddr_num[MAX_RECOG_OPERANDS];
|
int need_change = 0;
|
int need_change = 0;
|
/* We use last_op_addr_reload and the contents of the above arrays
|
/* We use last_op_addr_reload and the contents of the above arrays
|
first as flags - -2 means no instance encountered, -1 means exactly
|
first as flags - -2 means no instance encountered, -1 means exactly
|
one instance encountered.
|
one instance encountered.
|
If more than one instance has been encountered, we store the reload
|
If more than one instance has been encountered, we store the reload
|
number of the first reload of the kind in question; reload numbers
|
number of the first reload of the kind in question; reload numbers
|
are known to be non-negative. */
|
are known to be non-negative. */
|
for (i = 0; i < noperands; i++)
|
for (i = 0; i < noperands; i++)
|
first_inpaddr_num[i] = first_outpaddr_num[i] = -2;
|
first_inpaddr_num[i] = first_outpaddr_num[i] = -2;
|
for (i = n_reloads - 1; i >= 0; i--)
|
for (i = n_reloads - 1; i >= 0; i--)
|
{
|
{
|
switch (rld[i].when_needed)
|
switch (rld[i].when_needed)
|
{
|
{
|
case RELOAD_FOR_OPERAND_ADDRESS:
|
case RELOAD_FOR_OPERAND_ADDRESS:
|
if (++first_op_addr_num >= 0)
|
if (++first_op_addr_num >= 0)
|
{
|
{
|
first_op_addr_num = i;
|
first_op_addr_num = i;
|
need_change = 1;
|
need_change = 1;
|
}
|
}
|
break;
|
break;
|
case RELOAD_FOR_INPUT_ADDRESS:
|
case RELOAD_FOR_INPUT_ADDRESS:
|
if (++first_inpaddr_num[rld[i].opnum] >= 0)
|
if (++first_inpaddr_num[rld[i].opnum] >= 0)
|
{
|
{
|
first_inpaddr_num[rld[i].opnum] = i;
|
first_inpaddr_num[rld[i].opnum] = i;
|
need_change = 1;
|
need_change = 1;
|
}
|
}
|
break;
|
break;
|
case RELOAD_FOR_OUTPUT_ADDRESS:
|
case RELOAD_FOR_OUTPUT_ADDRESS:
|
if (++first_outpaddr_num[rld[i].opnum] >= 0)
|
if (++first_outpaddr_num[rld[i].opnum] >= 0)
|
{
|
{
|
first_outpaddr_num[rld[i].opnum] = i;
|
first_outpaddr_num[rld[i].opnum] = i;
|
need_change = 1;
|
need_change = 1;
|
}
|
}
|
break;
|
break;
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
if (need_change)
|
if (need_change)
|
{
|
{
|
for (i = 0; i < n_reloads; i++)
|
for (i = 0; i < n_reloads; i++)
|
{
|
{
|
int first_num;
|
int first_num;
|
enum reload_type type;
|
enum reload_type type;
|
|
|
switch (rld[i].when_needed)
|
switch (rld[i].when_needed)
|
{
|
{
|
case RELOAD_FOR_OPADDR_ADDR:
|
case RELOAD_FOR_OPADDR_ADDR:
|
first_num = first_op_addr_num;
|
first_num = first_op_addr_num;
|
type = RELOAD_FOR_OPERAND_ADDRESS;
|
type = RELOAD_FOR_OPERAND_ADDRESS;
|
break;
|
break;
|
case RELOAD_FOR_INPADDR_ADDRESS:
|
case RELOAD_FOR_INPADDR_ADDRESS:
|
first_num = first_inpaddr_num[rld[i].opnum];
|
first_num = first_inpaddr_num[rld[i].opnum];
|
type = RELOAD_FOR_INPUT_ADDRESS;
|
type = RELOAD_FOR_INPUT_ADDRESS;
|
break;
|
break;
|
case RELOAD_FOR_OUTADDR_ADDRESS:
|
case RELOAD_FOR_OUTADDR_ADDRESS:
|
first_num = first_outpaddr_num[rld[i].opnum];
|
first_num = first_outpaddr_num[rld[i].opnum];
|
type = RELOAD_FOR_OUTPUT_ADDRESS;
|
type = RELOAD_FOR_OUTPUT_ADDRESS;
|
break;
|
break;
|
default:
|
default:
|
continue;
|
continue;
|
}
|
}
|
if (first_num < 0)
|
if (first_num < 0)
|
continue;
|
continue;
|
else if (i > first_num)
|
else if (i > first_num)
|
rld[i].when_needed = type;
|
rld[i].when_needed = type;
|
else
|
else
|
{
|
{
|
/* Check if the only TYPE reload that uses reload I is
|
/* Check if the only TYPE reload that uses reload I is
|
reload FIRST_NUM. */
|
reload FIRST_NUM. */
|
for (j = n_reloads - 1; j > first_num; j--)
|
for (j = n_reloads - 1; j > first_num; j--)
|
{
|
{
|
if (rld[j].when_needed == type
|
if (rld[j].when_needed == type
|
&& (rld[i].secondary_p
|
&& (rld[i].secondary_p
|
? rld[j].secondary_in_reload == i
|
? rld[j].secondary_in_reload == i
|
: reg_mentioned_p (rld[i].in, rld[j].in)))
|
: reg_mentioned_p (rld[i].in, rld[j].in)))
|
{
|
{
|
rld[i].when_needed = type;
|
rld[i].when_needed = type;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* See if we have any reloads that are now allowed to be merged
|
/* See if we have any reloads that are now allowed to be merged
|
because we've changed when the reload is needed to
|
because we've changed when the reload is needed to
|
RELOAD_FOR_OPERAND_ADDRESS or RELOAD_FOR_OTHER_ADDRESS. Only
|
RELOAD_FOR_OPERAND_ADDRESS or RELOAD_FOR_OTHER_ADDRESS. Only
|
check for the most common cases. */
|
check for the most common cases. */
|
|
|
for (i = 0; i < n_reloads; i++)
|
for (i = 0; i < n_reloads; i++)
|
if (rld[i].in != 0 && rld[i].out == 0
|
if (rld[i].in != 0 && rld[i].out == 0
|
&& (rld[i].when_needed == RELOAD_FOR_OPERAND_ADDRESS
|
&& (rld[i].when_needed == RELOAD_FOR_OPERAND_ADDRESS
|
|| rld[i].when_needed == RELOAD_FOR_OPADDR_ADDR
|
|| rld[i].when_needed == RELOAD_FOR_OPADDR_ADDR
|
|| rld[i].when_needed == RELOAD_FOR_OTHER_ADDRESS))
|
|| rld[i].when_needed == RELOAD_FOR_OTHER_ADDRESS))
|
for (j = 0; j < n_reloads; j++)
|
for (j = 0; j < n_reloads; j++)
|
if (i != j && rld[j].in != 0 && rld[j].out == 0
|
if (i != j && rld[j].in != 0 && rld[j].out == 0
|
&& rld[j].when_needed == rld[i].when_needed
|
&& rld[j].when_needed == rld[i].when_needed
|
&& MATCHES (rld[i].in, rld[j].in)
|
&& MATCHES (rld[i].in, rld[j].in)
|
&& rld[i].class == rld[j].class
|
&& rld[i].class == rld[j].class
|
&& !rld[i].nocombine && !rld[j].nocombine
|
&& !rld[i].nocombine && !rld[j].nocombine
|
&& rld[i].reg_rtx == rld[j].reg_rtx)
|
&& rld[i].reg_rtx == rld[j].reg_rtx)
|
{
|
{
|
rld[i].opnum = MIN (rld[i].opnum, rld[j].opnum);
|
rld[i].opnum = MIN (rld[i].opnum, rld[j].opnum);
|
transfer_replacements (i, j);
|
transfer_replacements (i, j);
|
rld[j].in = 0;
|
rld[j].in = 0;
|
}
|
}
|
|
|
#ifdef HAVE_cc0
|
#ifdef HAVE_cc0
|
/* If we made any reloads for addresses, see if they violate a
|
/* If we made any reloads for addresses, see if they violate a
|
"no input reloads" requirement for this insn. But loads that we
|
"no input reloads" requirement for this insn. But loads that we
|
do after the insn (such as for output addresses) are fine. */
|
do after the insn (such as for output addresses) are fine. */
|
if (no_input_reloads)
|
if (no_input_reloads)
|
for (i = 0; i < n_reloads; i++)
|
for (i = 0; i < n_reloads; i++)
|
gcc_assert (rld[i].in == 0
|
gcc_assert (rld[i].in == 0
|
|| rld[i].when_needed == RELOAD_FOR_OUTADDR_ADDRESS
|
|| rld[i].when_needed == RELOAD_FOR_OUTADDR_ADDRESS
|
|| rld[i].when_needed == RELOAD_FOR_OUTPUT_ADDRESS);
|
|| rld[i].when_needed == RELOAD_FOR_OUTPUT_ADDRESS);
|
#endif
|
#endif
|
|
|
/* Compute reload_mode and reload_nregs. */
|
/* Compute reload_mode and reload_nregs. */
|
for (i = 0; i < n_reloads; i++)
|
for (i = 0; i < n_reloads; i++)
|
{
|
{
|
rld[i].mode
|
rld[i].mode
|
= (rld[i].inmode == VOIDmode
|
= (rld[i].inmode == VOIDmode
|
|| (GET_MODE_SIZE (rld[i].outmode)
|
|| (GET_MODE_SIZE (rld[i].outmode)
|
> GET_MODE_SIZE (rld[i].inmode)))
|
> GET_MODE_SIZE (rld[i].inmode)))
|
? rld[i].outmode : rld[i].inmode;
|
? rld[i].outmode : rld[i].inmode;
|
|
|
rld[i].nregs = CLASS_MAX_NREGS (rld[i].class, rld[i].mode);
|
rld[i].nregs = CLASS_MAX_NREGS (rld[i].class, rld[i].mode);
|
}
|
}
|
|
|
/* Special case a simple move with an input reload and a
|
/* Special case a simple move with an input reload and a
|
destination of a hard reg, if the hard reg is ok, use it. */
|
destination of a hard reg, if the hard reg is ok, use it. */
|
for (i = 0; i < n_reloads; i++)
|
for (i = 0; i < n_reloads; i++)
|
if (rld[i].when_needed == RELOAD_FOR_INPUT
|
if (rld[i].when_needed == RELOAD_FOR_INPUT
|
&& GET_CODE (PATTERN (insn)) == SET
|
&& GET_CODE (PATTERN (insn)) == SET
|
&& REG_P (SET_DEST (PATTERN (insn)))
|
&& REG_P (SET_DEST (PATTERN (insn)))
|
&& SET_SRC (PATTERN (insn)) == rld[i].in)
|
&& SET_SRC (PATTERN (insn)) == rld[i].in)
|
{
|
{
|
rtx dest = SET_DEST (PATTERN (insn));
|
rtx dest = SET_DEST (PATTERN (insn));
|
unsigned int regno = REGNO (dest);
|
unsigned int regno = REGNO (dest);
|
|
|
if (regno < FIRST_PSEUDO_REGISTER
|
if (regno < FIRST_PSEUDO_REGISTER
|
&& TEST_HARD_REG_BIT (reg_class_contents[rld[i].class], regno)
|
&& TEST_HARD_REG_BIT (reg_class_contents[rld[i].class], regno)
|
&& HARD_REGNO_MODE_OK (regno, rld[i].mode))
|
&& HARD_REGNO_MODE_OK (regno, rld[i].mode))
|
{
|
{
|
int nr = hard_regno_nregs[regno][rld[i].mode];
|
int nr = hard_regno_nregs[regno][rld[i].mode];
|
int ok = 1, nri;
|
int ok = 1, nri;
|
|
|
for (nri = 1; nri < nr; nri ++)
|
for (nri = 1; nri < nr; nri ++)
|
if (! TEST_HARD_REG_BIT (reg_class_contents[rld[i].class], regno + nri))
|
if (! TEST_HARD_REG_BIT (reg_class_contents[rld[i].class], regno + nri))
|
ok = 0;
|
ok = 0;
|
|
|
if (ok)
|
if (ok)
|
rld[i].reg_rtx = dest;
|
rld[i].reg_rtx = dest;
|
}
|
}
|
}
|
}
|
|
|
return retval;
|
return retval;
|
}
|
}
|
|
|
/* Return 1 if alternative number ALTNUM in constraint-string CONSTRAINT
|
/* Return 1 if alternative number ALTNUM in constraint-string CONSTRAINT
|
accepts a memory operand with constant address. */
|
accepts a memory operand with constant address. */
|
|
|
static int
|
static int
|
alternative_allows_memconst (const char *constraint, int altnum)
|
alternative_allows_memconst (const char *constraint, int altnum)
|
{
|
{
|
int c;
|
int c;
|
/* Skip alternatives before the one requested. */
|
/* Skip alternatives before the one requested. */
|
while (altnum > 0)
|
while (altnum > 0)
|
{
|
{
|
while (*constraint++ != ',');
|
while (*constraint++ != ',');
|
altnum--;
|
altnum--;
|
}
|
}
|
/* Scan the requested alternative for 'm' or 'o'.
|
/* Scan the requested alternative for 'm' or 'o'.
|
If one of them is present, this alternative accepts memory constants. */
|
If one of them is present, this alternative accepts memory constants. */
|
for (; (c = *constraint) && c != ',' && c != '#';
|
for (; (c = *constraint) && c != ',' && c != '#';
|
constraint += CONSTRAINT_LEN (c, constraint))
|
constraint += CONSTRAINT_LEN (c, constraint))
|
if (c == 'm' || c == 'o' || EXTRA_MEMORY_CONSTRAINT (c, constraint))
|
if (c == 'm' || c == 'o' || EXTRA_MEMORY_CONSTRAINT (c, constraint))
|
return 1;
|
return 1;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Scan X for memory references and scan the addresses for reloading.
|
/* Scan X for memory references and scan the addresses for reloading.
|
Also checks for references to "constant" regs that we want to eliminate
|
Also checks for references to "constant" regs that we want to eliminate
|
and replaces them with the values they stand for.
|
and replaces them with the values they stand for.
|
We may alter X destructively if it contains a reference to such.
|
We may alter X destructively if it contains a reference to such.
|
If X is just a constant reg, we return the equivalent value
|
If X is just a constant reg, we return the equivalent value
|
instead of X.
|
instead of X.
|
|
|
IND_LEVELS says how many levels of indirect addressing this machine
|
IND_LEVELS says how many levels of indirect addressing this machine
|
supports.
|
supports.
|
|
|
OPNUM and TYPE identify the purpose of the reload.
|
OPNUM and TYPE identify the purpose of the reload.
|
|
|
IS_SET_DEST is true if X is the destination of a SET, which is not
|
IS_SET_DEST is true if X is the destination of a SET, which is not
|
appropriate to be replaced by a constant.
|
appropriate to be replaced by a constant.
|
|
|
INSN, if nonzero, is the insn in which we do the reload. It is used
|
INSN, if nonzero, is the insn in which we do the reload. It is used
|
to determine if we may generate output reloads, and where to put USEs
|
to determine if we may generate output reloads, and where to put USEs
|
for pseudos that we have to replace with stack slots.
|
for pseudos that we have to replace with stack slots.
|
|
|
ADDRESS_RELOADED. If nonzero, is a pointer to where we put the
|
ADDRESS_RELOADED. If nonzero, is a pointer to where we put the
|
result of find_reloads_address. */
|
result of find_reloads_address. */
|
|
|
static rtx
|
static rtx
|
find_reloads_toplev (rtx x, int opnum, enum reload_type type,
|
find_reloads_toplev (rtx x, int opnum, enum reload_type type,
|
int ind_levels, int is_set_dest, rtx insn,
|
int ind_levels, int is_set_dest, rtx insn,
|
int *address_reloaded)
|
int *address_reloaded)
|
{
|
{
|
RTX_CODE code = GET_CODE (x);
|
RTX_CODE code = GET_CODE (x);
|
|
|
const char *fmt = GET_RTX_FORMAT (code);
|
const char *fmt = GET_RTX_FORMAT (code);
|
int i;
|
int i;
|
int copied;
|
int copied;
|
|
|
if (code == REG)
|
if (code == REG)
|
{
|
{
|
/* This code is duplicated for speed in find_reloads. */
|
/* This code is duplicated for speed in find_reloads. */
|
int regno = REGNO (x);
|
int regno = REGNO (x);
|
if (reg_equiv_constant[regno] != 0 && !is_set_dest)
|
if (reg_equiv_constant[regno] != 0 && !is_set_dest)
|
x = reg_equiv_constant[regno];
|
x = reg_equiv_constant[regno];
|
#if 0
|
#if 0
|
/* This creates (subreg (mem...)) which would cause an unnecessary
|
/* This creates (subreg (mem...)) which would cause an unnecessary
|
reload of the mem. */
|
reload of the mem. */
|
else if (reg_equiv_mem[regno] != 0)
|
else if (reg_equiv_mem[regno] != 0)
|
x = reg_equiv_mem[regno];
|
x = reg_equiv_mem[regno];
|
#endif
|
#endif
|
else if (reg_equiv_memory_loc[regno]
|
else if (reg_equiv_memory_loc[regno]
|
&& (reg_equiv_address[regno] != 0 || num_not_at_initial_offset))
|
&& (reg_equiv_address[regno] != 0 || num_not_at_initial_offset))
|
{
|
{
|
rtx mem = make_memloc (x, regno);
|
rtx mem = make_memloc (x, regno);
|
if (reg_equiv_address[regno]
|
if (reg_equiv_address[regno]
|
|| ! rtx_equal_p (mem, reg_equiv_mem[regno]))
|
|| ! rtx_equal_p (mem, reg_equiv_mem[regno]))
|
{
|
{
|
/* If this is not a toplevel operand, find_reloads doesn't see
|
/* If this is not a toplevel operand, find_reloads doesn't see
|
this substitution. We have to emit a USE of the pseudo so
|
this substitution. We have to emit a USE of the pseudo so
|
that delete_output_reload can see it. */
|
that delete_output_reload can see it. */
|
if (replace_reloads && recog_data.operand[opnum] != x)
|
if (replace_reloads && recog_data.operand[opnum] != x)
|
/* We mark the USE with QImode so that we recognize it
|
/* We mark the USE with QImode so that we recognize it
|
as one that can be safely deleted at the end of
|
as one that can be safely deleted at the end of
|
reload. */
|
reload. */
|
PUT_MODE (emit_insn_before (gen_rtx_USE (VOIDmode, x), insn),
|
PUT_MODE (emit_insn_before (gen_rtx_USE (VOIDmode, x), insn),
|
QImode);
|
QImode);
|
x = mem;
|
x = mem;
|
i = find_reloads_address (GET_MODE (x), &x, XEXP (x, 0), &XEXP (x, 0),
|
i = find_reloads_address (GET_MODE (x), &x, XEXP (x, 0), &XEXP (x, 0),
|
opnum, type, ind_levels, insn);
|
opnum, type, ind_levels, insn);
|
if (x != mem)
|
if (x != mem)
|
push_reg_equiv_alt_mem (regno, x);
|
push_reg_equiv_alt_mem (regno, x);
|
if (address_reloaded)
|
if (address_reloaded)
|
*address_reloaded = i;
|
*address_reloaded = i;
|
}
|
}
|
}
|
}
|
return x;
|
return x;
|
}
|
}
|
if (code == MEM)
|
if (code == MEM)
|
{
|
{
|
rtx tem = x;
|
rtx tem = x;
|
|
|
i = find_reloads_address (GET_MODE (x), &tem, XEXP (x, 0), &XEXP (x, 0),
|
i = find_reloads_address (GET_MODE (x), &tem, XEXP (x, 0), &XEXP (x, 0),
|
opnum, type, ind_levels, insn);
|
opnum, type, ind_levels, insn);
|
if (address_reloaded)
|
if (address_reloaded)
|
*address_reloaded = i;
|
*address_reloaded = i;
|
|
|
return tem;
|
return tem;
|
}
|
}
|
|
|
if (code == SUBREG && REG_P (SUBREG_REG (x)))
|
if (code == SUBREG && REG_P (SUBREG_REG (x)))
|
{
|
{
|
/* Check for SUBREG containing a REG that's equivalent to a
|
/* Check for SUBREG containing a REG that's equivalent to a
|
constant. If the constant has a known value, truncate it
|
constant. If the constant has a known value, truncate it
|
right now. Similarly if we are extracting a single-word of a
|
right now. Similarly if we are extracting a single-word of a
|
multi-word constant. If the constant is symbolic, allow it
|
multi-word constant. If the constant is symbolic, allow it
|
to be substituted normally. push_reload will strip the
|
to be substituted normally. push_reload will strip the
|
subreg later. The constant must not be VOIDmode, because we
|
subreg later. The constant must not be VOIDmode, because we
|
will lose the mode of the register (this should never happen
|
will lose the mode of the register (this should never happen
|
because one of the cases above should handle it). */
|
because one of the cases above should handle it). */
|
|
|
int regno = REGNO (SUBREG_REG (x));
|
int regno = REGNO (SUBREG_REG (x));
|
rtx tem;
|
rtx tem;
|
|
|
if (subreg_lowpart_p (x)
|
if (subreg_lowpart_p (x)
|
&& regno >= FIRST_PSEUDO_REGISTER
|
&& regno >= FIRST_PSEUDO_REGISTER
|
&& reg_renumber[regno] < 0
|
&& reg_renumber[regno] < 0
|
&& reg_equiv_constant[regno] != 0
|
&& reg_equiv_constant[regno] != 0
|
&& (tem = gen_lowpart_common (GET_MODE (x),
|
&& (tem = gen_lowpart_common (GET_MODE (x),
|
reg_equiv_constant[regno])) != 0)
|
reg_equiv_constant[regno])) != 0)
|
return tem;
|
return tem;
|
|
|
if (regno >= FIRST_PSEUDO_REGISTER
|
if (regno >= FIRST_PSEUDO_REGISTER
|
&& reg_renumber[regno] < 0
|
&& reg_renumber[regno] < 0
|
&& reg_equiv_constant[regno] != 0)
|
&& reg_equiv_constant[regno] != 0)
|
{
|
{
|
tem =
|
tem =
|
simplify_gen_subreg (GET_MODE (x), reg_equiv_constant[regno],
|
simplify_gen_subreg (GET_MODE (x), reg_equiv_constant[regno],
|
GET_MODE (SUBREG_REG (x)), SUBREG_BYTE (x));
|
GET_MODE (SUBREG_REG (x)), SUBREG_BYTE (x));
|
gcc_assert (tem);
|
gcc_assert (tem);
|
return tem;
|
return tem;
|
}
|
}
|
|
|
/* If the subreg contains a reg that will be converted to a mem,
|
/* If the subreg contains a reg that will be converted to a mem,
|
convert the subreg to a narrower memref now.
|
convert the subreg to a narrower memref now.
|
Otherwise, we would get (subreg (mem ...) ...),
|
Otherwise, we would get (subreg (mem ...) ...),
|
which would force reload of the mem.
|
which would force reload of the mem.
|
|
|
We also need to do this if there is an equivalent MEM that is
|
We also need to do this if there is an equivalent MEM that is
|
not offsettable. In that case, alter_subreg would produce an
|
not offsettable. In that case, alter_subreg would produce an
|
invalid address on big-endian machines.
|
invalid address on big-endian machines.
|
|
|
For machines that extend byte loads, we must not reload using
|
For machines that extend byte loads, we must not reload using
|
a wider mode if we have a paradoxical SUBREG. find_reloads will
|
a wider mode if we have a paradoxical SUBREG. find_reloads will
|
force a reload in that case. So we should not do anything here. */
|
force a reload in that case. So we should not do anything here. */
|
|
|
if (regno >= FIRST_PSEUDO_REGISTER
|
if (regno >= FIRST_PSEUDO_REGISTER
|
#ifdef LOAD_EXTEND_OP
|
#ifdef LOAD_EXTEND_OP
|
&& (GET_MODE_SIZE (GET_MODE (x))
|
&& (GET_MODE_SIZE (GET_MODE (x))
|
<= GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))))
|
<= GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))))
|
#endif
|
#endif
|
&& (reg_equiv_address[regno] != 0
|
&& (reg_equiv_address[regno] != 0
|
|| (reg_equiv_mem[regno] != 0
|
|| (reg_equiv_mem[regno] != 0
|
&& (! strict_memory_address_p (GET_MODE (x),
|
&& (! strict_memory_address_p (GET_MODE (x),
|
XEXP (reg_equiv_mem[regno], 0))
|
XEXP (reg_equiv_mem[regno], 0))
|
|| ! offsettable_memref_p (reg_equiv_mem[regno])
|
|| ! offsettable_memref_p (reg_equiv_mem[regno])
|
|| num_not_at_initial_offset))))
|
|| num_not_at_initial_offset))))
|
x = find_reloads_subreg_address (x, 1, opnum, type, ind_levels,
|
x = find_reloads_subreg_address (x, 1, opnum, type, ind_levels,
|
insn);
|
insn);
|
}
|
}
|
|
|
for (copied = 0, i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
for (copied = 0, i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
{
|
{
|
if (fmt[i] == 'e')
|
if (fmt[i] == 'e')
|
{
|
{
|
rtx new_part = find_reloads_toplev (XEXP (x, i), opnum, type,
|
rtx new_part = find_reloads_toplev (XEXP (x, i), opnum, type,
|
ind_levels, is_set_dest, insn,
|
ind_levels, is_set_dest, insn,
|
address_reloaded);
|
address_reloaded);
|
/* If we have replaced a reg with it's equivalent memory loc -
|
/* If we have replaced a reg with it's equivalent memory loc -
|
that can still be handled here e.g. if it's in a paradoxical
|
that can still be handled here e.g. if it's in a paradoxical
|
subreg - we must make the change in a copy, rather than using
|
subreg - we must make the change in a copy, rather than using
|
a destructive change. This way, find_reloads can still elect
|
a destructive change. This way, find_reloads can still elect
|
not to do the change. */
|
not to do the change. */
|
if (new_part != XEXP (x, i) && ! CONSTANT_P (new_part) && ! copied)
|
if (new_part != XEXP (x, i) && ! CONSTANT_P (new_part) && ! copied)
|
{
|
{
|
x = shallow_copy_rtx (x);
|
x = shallow_copy_rtx (x);
|
copied = 1;
|
copied = 1;
|
}
|
}
|
XEXP (x, i) = new_part;
|
XEXP (x, i) = new_part;
|
}
|
}
|
}
|
}
|
return x;
|
return x;
|
}
|
}
|
|
|
/* Return a mem ref for the memory equivalent of reg REGNO.
|
/* Return a mem ref for the memory equivalent of reg REGNO.
|
This mem ref is not shared with anything. */
|
This mem ref is not shared with anything. */
|
|
|
static rtx
|
static rtx
|
make_memloc (rtx ad, int regno)
|
make_memloc (rtx ad, int regno)
|
{
|
{
|
/* We must rerun eliminate_regs, in case the elimination
|
/* We must rerun eliminate_regs, in case the elimination
|
offsets have changed. */
|
offsets have changed. */
|
rtx tem
|
rtx tem
|
= XEXP (eliminate_regs (reg_equiv_memory_loc[regno], 0, NULL_RTX), 0);
|
= XEXP (eliminate_regs (reg_equiv_memory_loc[regno], 0, NULL_RTX), 0);
|
|
|
/* If TEM might contain a pseudo, we must copy it to avoid
|
/* If TEM might contain a pseudo, we must copy it to avoid
|
modifying it when we do the substitution for the reload. */
|
modifying it when we do the substitution for the reload. */
|
if (rtx_varies_p (tem, 0))
|
if (rtx_varies_p (tem, 0))
|
tem = copy_rtx (tem);
|
tem = copy_rtx (tem);
|
|
|
tem = replace_equiv_address_nv (reg_equiv_memory_loc[regno], tem);
|
tem = replace_equiv_address_nv (reg_equiv_memory_loc[regno], tem);
|
tem = adjust_address_nv (tem, GET_MODE (ad), 0);
|
tem = adjust_address_nv (tem, GET_MODE (ad), 0);
|
|
|
/* Copy the result if it's still the same as the equivalence, to avoid
|
/* Copy the result if it's still the same as the equivalence, to avoid
|
modifying it when we do the substitution for the reload. */
|
modifying it when we do the substitution for the reload. */
|
if (tem == reg_equiv_memory_loc[regno])
|
if (tem == reg_equiv_memory_loc[regno])
|
tem = copy_rtx (tem);
|
tem = copy_rtx (tem);
|
return tem;
|
return tem;
|
}
|
}
|
|
|
/* Returns true if AD could be turned into a valid memory reference
|
/* 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. */
|
register. */
|
|
|
static int
|
static int
|
maybe_memory_address_p (enum machine_mode mode, rtx ad, rtx *part)
|
maybe_memory_address_p (enum machine_mode mode, rtx ad, rtx *part)
|
{
|
{
|
int retv;
|
int retv;
|
rtx tem = *part;
|
rtx tem = *part;
|
rtx reg = gen_rtx_REG (GET_MODE (tem), max_reg_num ());
|
rtx reg = gen_rtx_REG (GET_MODE (tem), max_reg_num ());
|
|
|
*part = reg;
|
*part = reg;
|
retv = memory_address_p (mode, ad);
|
retv = memory_address_p (mode, ad);
|
*part = tem;
|
*part = tem;
|
|
|
return retv;
|
return retv;
|
}
|
}
|
|
|
/* Record all reloads needed for handling memory address AD
|
/* Record all reloads needed for handling memory address AD
|
which appears in *LOC in a memory reference to mode MODE
|
which appears in *LOC in a memory reference to mode MODE
|
which itself is found in location *MEMREFLOC.
|
which itself is found in location *MEMREFLOC.
|
Note that we take shortcuts assuming that no multi-reg machine mode
|
Note that we take shortcuts assuming that no multi-reg machine mode
|
occurs as part of an address.
|
occurs as part of an address.
|
|
|
OPNUM and TYPE specify the purpose of this reload.
|
OPNUM and TYPE specify the purpose of this reload.
|
|
|
IND_LEVELS says how many levels of indirect addressing this machine
|
IND_LEVELS says how many levels of indirect addressing this machine
|
supports.
|
supports.
|
|
|
INSN, if nonzero, is the insn in which we do the reload. It is used
|
INSN, if nonzero, is the insn in which we do the reload. It is used
|
to determine if we may generate output reloads, and where to put USEs
|
to determine if we may generate output reloads, and where to put USEs
|
for pseudos that we have to replace with stack slots.
|
for pseudos that we have to replace with stack slots.
|
|
|
Value is one if this address is reloaded or replaced as a whole; it is
|
Value is one if this address is reloaded or replaced as a whole; it is
|
zero if the top level of this address was not reloaded or replaced, and
|
zero if the top level of this address was not reloaded or replaced, and
|
it is -1 if it may or may not have been reloaded or replaced.
|
it is -1 if it may or may not have been reloaded or replaced.
|
|
|
Note that there is no verification that the address will be valid after
|
Note that there is no verification that the address will be valid after
|
this routine does its work. Instead, we rely on the fact that the address
|
this routine does its work. Instead, we rely on the fact that the address
|
was valid when reload started. So we need only undo things that reload
|
was valid when reload started. So we need only undo things that reload
|
could have broken. These are wrong register types, pseudos not allocated
|
could have broken. These are wrong register types, pseudos not allocated
|
to a hard register, and frame pointer elimination. */
|
to a hard register, and frame pointer elimination. */
|
|
|
static int
|
static int
|
find_reloads_address (enum machine_mode mode, rtx *memrefloc, rtx ad,
|
find_reloads_address (enum machine_mode mode, rtx *memrefloc, rtx ad,
|
rtx *loc, int opnum, enum reload_type type,
|
rtx *loc, int opnum, enum reload_type type,
|
int ind_levels, rtx insn)
|
int ind_levels, rtx insn)
|
{
|
{
|
int regno;
|
int regno;
|
int removed_and = 0;
|
int removed_and = 0;
|
int op_index;
|
int op_index;
|
rtx tem;
|
rtx tem;
|
|
|
/* If the address is a register, see if it is a legitimate address and
|
/* If the address is a register, see if it is a legitimate address and
|
reload if not. We first handle the cases where we need not reload
|
reload if not. We first handle the cases where we need not reload
|
or where we must reload in a non-standard way. */
|
or where we must reload in a non-standard way. */
|
|
|
if (REG_P (ad))
|
if (REG_P (ad))
|
{
|
{
|
regno = REGNO (ad);
|
regno = REGNO (ad);
|
|
|
/* If the register is equivalent to an invariant expression, substitute
|
/* If the register is equivalent to an invariant expression, substitute
|
the invariant, and eliminate any eliminable register references. */
|
the invariant, and eliminate any eliminable register references. */
|
tem = reg_equiv_constant[regno];
|
tem = reg_equiv_constant[regno];
|
if (tem != 0
|
if (tem != 0
|
&& (tem = eliminate_regs (tem, mode, insn))
|
&& (tem = eliminate_regs (tem, mode, insn))
|
&& strict_memory_address_p (mode, tem))
|
&& strict_memory_address_p (mode, tem))
|
{
|
{
|
*loc = ad = tem;
|
*loc = ad = tem;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
tem = reg_equiv_memory_loc[regno];
|
tem = reg_equiv_memory_loc[regno];
|
if (tem != 0)
|
if (tem != 0)
|
{
|
{
|
if (reg_equiv_address[regno] != 0 || num_not_at_initial_offset)
|
if (reg_equiv_address[regno] != 0 || num_not_at_initial_offset)
|
{
|
{
|
tem = make_memloc (ad, regno);
|
tem = make_memloc (ad, regno);
|
if (! strict_memory_address_p (GET_MODE (tem), XEXP (tem, 0)))
|
if (! strict_memory_address_p (GET_MODE (tem), XEXP (tem, 0)))
|
{
|
{
|
rtx orig = tem;
|
rtx orig = tem;
|
|
|
find_reloads_address (GET_MODE (tem), &tem, XEXP (tem, 0),
|
find_reloads_address (GET_MODE (tem), &tem, XEXP (tem, 0),
|
&XEXP (tem, 0), opnum,
|
&XEXP (tem, 0), opnum,
|
ADDR_TYPE (type), ind_levels, insn);
|
ADDR_TYPE (type), ind_levels, insn);
|
if (tem != orig)
|
if (tem != orig)
|
push_reg_equiv_alt_mem (regno, tem);
|
push_reg_equiv_alt_mem (regno, tem);
|
}
|
}
|
/* We can avoid a reload if the register's equivalent memory
|
/* We can avoid a reload if the register's equivalent memory
|
expression is valid as an indirect memory address.
|
expression is valid as an indirect memory address.
|
But not all addresses are valid in a mem used as an indirect
|
But not all addresses are valid in a mem used as an indirect
|
address: only reg or reg+constant. */
|
address: only reg or reg+constant. */
|
|
|
if (ind_levels > 0
|
if (ind_levels > 0
|
&& strict_memory_address_p (mode, tem)
|
&& strict_memory_address_p (mode, tem)
|
&& (REG_P (XEXP (tem, 0))
|
&& (REG_P (XEXP (tem, 0))
|
|| (GET_CODE (XEXP (tem, 0)) == PLUS
|
|| (GET_CODE (XEXP (tem, 0)) == PLUS
|
&& REG_P (XEXP (XEXP (tem, 0), 0))
|
&& REG_P (XEXP (XEXP (tem, 0), 0))
|
&& CONSTANT_P (XEXP (XEXP (tem, 0), 1)))))
|
&& CONSTANT_P (XEXP (XEXP (tem, 0), 1)))))
|
{
|
{
|
/* TEM is not the same as what we'll be replacing the
|
/* TEM is not the same as what we'll be replacing the
|
pseudo with after reload, put a USE in front of INSN
|
pseudo with after reload, put a USE in front of INSN
|
in the final reload pass. */
|
in the final reload pass. */
|
if (replace_reloads
|
if (replace_reloads
|
&& num_not_at_initial_offset
|
&& num_not_at_initial_offset
|
&& ! rtx_equal_p (tem, reg_equiv_mem[regno]))
|
&& ! rtx_equal_p (tem, reg_equiv_mem[regno]))
|
{
|
{
|
*loc = tem;
|
*loc = tem;
|
/* We mark the USE with QImode so that we
|
/* We mark the USE with QImode so that we
|
recognize it as one that can be safely
|
recognize it as one that can be safely
|
deleted at the end of reload. */
|
deleted at the end of reload. */
|
PUT_MODE (emit_insn_before (gen_rtx_USE (VOIDmode, ad),
|
PUT_MODE (emit_insn_before (gen_rtx_USE (VOIDmode, ad),
|
insn), QImode);
|
insn), QImode);
|
|
|
/* This doesn't really count as replacing the address
|
/* This doesn't really count as replacing the address
|
as a whole, since it is still a memory access. */
|
as a whole, since it is still a memory access. */
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
ad = tem;
|
ad = tem;
|
}
|
}
|
}
|
}
|
|
|
/* The only remaining case where we can avoid a reload is if this is a
|
/* The only remaining case where we can avoid a reload is if this is a
|
hard register that is valid as a base register and which is not the
|
hard register that is valid as a base register and which is not the
|
subject of a CLOBBER in this insn. */
|
subject of a CLOBBER in this insn. */
|
|
|
else if (regno < FIRST_PSEUDO_REGISTER
|
else if (regno < FIRST_PSEUDO_REGISTER
|
&& regno_ok_for_base_p (regno, mode, MEM, SCRATCH)
|
&& regno_ok_for_base_p (regno, mode, MEM, SCRATCH)
|
&& ! regno_clobbered_p (regno, this_insn, mode, 0))
|
&& ! regno_clobbered_p (regno, this_insn, mode, 0))
|
return 0;
|
return 0;
|
|
|
/* If we do not have one of the cases above, we must do the reload. */
|
/* If we do not have one of the cases above, we must do the reload. */
|
push_reload (ad, NULL_RTX, loc, (rtx*) 0, base_reg_class (mode, MEM, SCRATCH),
|
push_reload (ad, NULL_RTX, loc, (rtx*) 0, base_reg_class (mode, MEM, SCRATCH),
|
GET_MODE (ad), VOIDmode, 0, 0, opnum, type);
|
GET_MODE (ad), VOIDmode, 0, 0, opnum, type);
|
return 1;
|
return 1;
|
}
|
}
|
|
|
if (strict_memory_address_p (mode, ad))
|
if (strict_memory_address_p (mode, ad))
|
{
|
{
|
/* The address appears valid, so reloads are not needed.
|
/* The address appears valid, so reloads are not needed.
|
But the address may contain an eliminable register.
|
But the address may contain an eliminable register.
|
This can happen because a machine with indirect addressing
|
This can happen because a machine with indirect addressing
|
may consider a pseudo register by itself a valid address even when
|
may consider a pseudo register by itself a valid address even when
|
it has failed to get a hard reg.
|
it has failed to get a hard reg.
|
So do a tree-walk to find and eliminate all such regs. */
|
So do a tree-walk to find and eliminate all such regs. */
|
|
|
/* But first quickly dispose of a common case. */
|
/* But first quickly dispose of a common case. */
|
if (GET_CODE (ad) == PLUS
|
if (GET_CODE (ad) == PLUS
|
&& GET_CODE (XEXP (ad, 1)) == CONST_INT
|
&& GET_CODE (XEXP (ad, 1)) == CONST_INT
|
&& REG_P (XEXP (ad, 0))
|
&& REG_P (XEXP (ad, 0))
|
&& reg_equiv_constant[REGNO (XEXP (ad, 0))] == 0)
|
&& reg_equiv_constant[REGNO (XEXP (ad, 0))] == 0)
|
return 0;
|
return 0;
|
|
|
subst_reg_equivs_changed = 0;
|
subst_reg_equivs_changed = 0;
|
*loc = subst_reg_equivs (ad, insn);
|
*loc = subst_reg_equivs (ad, insn);
|
|
|
if (! subst_reg_equivs_changed)
|
if (! subst_reg_equivs_changed)
|
return 0;
|
return 0;
|
|
|
/* Check result for validity after substitution. */
|
/* Check result for validity after substitution. */
|
if (strict_memory_address_p (mode, ad))
|
if (strict_memory_address_p (mode, ad))
|
return 0;
|
return 0;
|
}
|
}
|
|
|
#ifdef LEGITIMIZE_RELOAD_ADDRESS
|
#ifdef LEGITIMIZE_RELOAD_ADDRESS
|
do
|
do
|
{
|
{
|
if (memrefloc)
|
if (memrefloc)
|
{
|
{
|
LEGITIMIZE_RELOAD_ADDRESS (ad, GET_MODE (*memrefloc), opnum, type,
|
LEGITIMIZE_RELOAD_ADDRESS (ad, GET_MODE (*memrefloc), opnum, type,
|
ind_levels, win);
|
ind_levels, win);
|
}
|
}
|
break;
|
break;
|
win:
|
win:
|
*memrefloc = copy_rtx (*memrefloc);
|
*memrefloc = copy_rtx (*memrefloc);
|
XEXP (*memrefloc, 0) = ad;
|
XEXP (*memrefloc, 0) = ad;
|
move_replacements (&ad, &XEXP (*memrefloc, 0));
|
move_replacements (&ad, &XEXP (*memrefloc, 0));
|
return -1;
|
return -1;
|
}
|
}
|
while (0);
|
while (0);
|
#endif
|
#endif
|
|
|
/* The address is not valid. We have to figure out why. First see if
|
/* The address is not valid. We have to figure out why. First see if
|
we have an outer AND and remove it if so. Then analyze what's inside. */
|
we have an outer AND and remove it if so. Then analyze what's inside. */
|
|
|
if (GET_CODE (ad) == AND)
|
if (GET_CODE (ad) == AND)
|
{
|
{
|
removed_and = 1;
|
removed_and = 1;
|
loc = &XEXP (ad, 0);
|
loc = &XEXP (ad, 0);
|
ad = *loc;
|
ad = *loc;
|
}
|
}
|
|
|
/* One possibility for why the address is invalid is that it is itself
|
/* One possibility for why the address is invalid is that it is itself
|
a MEM. This can happen when the frame pointer is being eliminated, a
|
a MEM. This can happen when the frame pointer is being eliminated, a
|
pseudo is not allocated to a hard register, and the offset between the
|
pseudo is not allocated to a hard register, and the offset between the
|
frame and stack pointers is not its initial value. In that case the
|
frame and stack pointers is not its initial value. In that case the
|
pseudo will have been replaced by a MEM referring to the
|
pseudo will have been replaced by a MEM referring to the
|
stack pointer. */
|
stack pointer. */
|
if (MEM_P (ad))
|
if (MEM_P (ad))
|
{
|
{
|
/* First ensure that the address in this MEM is valid. Then, unless
|
/* First ensure that the address in this MEM is valid. Then, unless
|
indirect addresses are valid, reload the MEM into a register. */
|
indirect addresses are valid, reload the MEM into a register. */
|
tem = ad;
|
tem = ad;
|
find_reloads_address (GET_MODE (ad), &tem, XEXP (ad, 0), &XEXP (ad, 0),
|
find_reloads_address (GET_MODE (ad), &tem, XEXP (ad, 0), &XEXP (ad, 0),
|
opnum, ADDR_TYPE (type),
|
opnum, ADDR_TYPE (type),
|
ind_levels == 0 ? 0 : ind_levels - 1, insn);
|
ind_levels == 0 ? 0 : ind_levels - 1, insn);
|
|
|
/* If tem was changed, then we must create a new memory reference to
|
/* If tem was changed, then we must create a new memory reference to
|
hold it and store it back into memrefloc. */
|
hold it and store it back into memrefloc. */
|
if (tem != ad && memrefloc)
|
if (tem != ad && memrefloc)
|
{
|
{
|
*memrefloc = copy_rtx (*memrefloc);
|
*memrefloc = copy_rtx (*memrefloc);
|
copy_replacements (tem, XEXP (*memrefloc, 0));
|
copy_replacements (tem, XEXP (*memrefloc, 0));
|
loc = &XEXP (*memrefloc, 0);
|
loc = &XEXP (*memrefloc, 0);
|
if (removed_and)
|
if (removed_and)
|
loc = &XEXP (*loc, 0);
|
loc = &XEXP (*loc, 0);
|
}
|
}
|
|
|
/* Check similar cases as for indirect addresses as above except
|
/* Check similar cases as for indirect addresses as above except
|
that we can allow pseudos and a MEM since they should have been
|
that we can allow pseudos and a MEM since they should have been
|
taken care of above. */
|
taken care of above. */
|
|
|
if (ind_levels == 0
|
if (ind_levels == 0
|
|| (GET_CODE (XEXP (tem, 0)) == SYMBOL_REF && ! indirect_symref_ok)
|
|| (GET_CODE (XEXP (tem, 0)) == SYMBOL_REF && ! indirect_symref_ok)
|
|| MEM_P (XEXP (tem, 0))
|
|| MEM_P (XEXP (tem, 0))
|
|| ! (REG_P (XEXP (tem, 0))
|
|| ! (REG_P (XEXP (tem, 0))
|
|| (GET_CODE (XEXP (tem, 0)) == PLUS
|
|| (GET_CODE (XEXP (tem, 0)) == PLUS
|
&& REG_P (XEXP (XEXP (tem, 0), 0))
|
&& REG_P (XEXP (XEXP (tem, 0), 0))
|
&& GET_CODE (XEXP (XEXP (tem, 0), 1)) == CONST_INT)))
|
&& GET_CODE (XEXP (XEXP (tem, 0), 1)) == CONST_INT)))
|
{
|
{
|
/* Must use TEM here, not AD, since it is the one that will
|
/* Must use TEM here, not AD, since it is the one that will
|
have any subexpressions reloaded, if needed. */
|
have any subexpressions reloaded, if needed. */
|
push_reload (tem, NULL_RTX, loc, (rtx*) 0,
|
push_reload (tem, NULL_RTX, loc, (rtx*) 0,
|
base_reg_class (mode, MEM, SCRATCH), GET_MODE (tem),
|
base_reg_class (mode, MEM, SCRATCH), GET_MODE (tem),
|
VOIDmode, 0,
|
VOIDmode, 0,
|
0, opnum, type);
|
0, opnum, type);
|
return ! removed_and;
|
return ! removed_and;
|
}
|
}
|
else
|
else
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* If we have address of a stack slot but it's not valid because the
|
/* If we have address of a stack slot but it's not valid because the
|
displacement is too large, compute the sum in a register.
|
displacement is too large, compute the sum in a register.
|
Handle all base registers here, not just fp/ap/sp, because on some
|
Handle all base registers here, not just fp/ap/sp, because on some
|
targets (namely SH) we can also get too large displacements from
|
targets (namely SH) we can also get too large displacements from
|
big-endian corrections. */
|
big-endian corrections. */
|
else if (GET_CODE (ad) == PLUS
|
else if (GET_CODE (ad) == PLUS
|
&& REG_P (XEXP (ad, 0))
|
&& REG_P (XEXP (ad, 0))
|
&& REGNO (XEXP (ad, 0)) < FIRST_PSEUDO_REGISTER
|
&& REGNO (XEXP (ad, 0)) < FIRST_PSEUDO_REGISTER
|
&& GET_CODE (XEXP (ad, 1)) == CONST_INT
|
&& GET_CODE (XEXP (ad, 1)) == CONST_INT
|
&& regno_ok_for_base_p (REGNO (XEXP (ad, 0)), mode, PLUS,
|
&& regno_ok_for_base_p (REGNO (XEXP (ad, 0)), mode, PLUS,
|
CONST_INT))
|
CONST_INT))
|
|
|
{
|
{
|
/* Unshare the MEM rtx so we can safely alter it. */
|
/* Unshare the MEM rtx so we can safely alter it. */
|
if (memrefloc)
|
if (memrefloc)
|
{
|
{
|
*memrefloc = copy_rtx (*memrefloc);
|
*memrefloc = copy_rtx (*memrefloc);
|
loc = &XEXP (*memrefloc, 0);
|
loc = &XEXP (*memrefloc, 0);
|
if (removed_and)
|
if (removed_and)
|
loc = &XEXP (*loc, 0);
|
loc = &XEXP (*loc, 0);
|
}
|
}
|
|
|
if (double_reg_address_ok)
|
if (double_reg_address_ok)
|
{
|
{
|
/* Unshare the sum as well. */
|
/* Unshare the sum as well. */
|
*loc = ad = copy_rtx (ad);
|
*loc = ad = copy_rtx (ad);
|
|
|
/* Reload the displacement into an index reg.
|
/* Reload the displacement into an index reg.
|
We assume the frame pointer or arg pointer is a base reg. */
|
We assume the frame pointer or arg pointer is a base reg. */
|
find_reloads_address_part (XEXP (ad, 1), &XEXP (ad, 1),
|
find_reloads_address_part (XEXP (ad, 1), &XEXP (ad, 1),
|
INDEX_REG_CLASS, GET_MODE (ad), opnum,
|
INDEX_REG_CLASS, GET_MODE (ad), opnum,
|
type, ind_levels);
|
type, ind_levels);
|
return 0;
|
return 0;
|
}
|
}
|
else
|
else
|
{
|
{
|
/* If the sum of two regs is not necessarily valid,
|
/* If the sum of two regs is not necessarily valid,
|
reload the sum into a base reg.
|
reload the sum into a base reg.
|
That will at least work. */
|
That will at least work. */
|
find_reloads_address_part (ad, loc,
|
find_reloads_address_part (ad, loc,
|
base_reg_class (mode, MEM, SCRATCH),
|
base_reg_class (mode, MEM, SCRATCH),
|
Pmode, opnum, type, ind_levels);
|
Pmode, opnum, type, ind_levels);
|
}
|
}
|
return ! removed_and;
|
return ! removed_and;
|
}
|
}
|
|
|
/* If we have an indexed stack slot, there are three possible reasons why
|
/* If we have an indexed stack slot, there are three possible reasons why
|
it might be invalid: The index might need to be reloaded, the address
|
it might be invalid: The index might need to be reloaded, the address
|
might have been made by frame pointer elimination and hence have a
|
might have been made by frame pointer elimination and hence have a
|
constant out of range, or both reasons might apply.
|
constant out of range, or both reasons might apply.
|
|
|
We can easily check for an index needing reload, but even if that is the
|
We can easily check for an index needing reload, but even if that is the
|
case, we might also have an invalid constant. To avoid making the
|
case, we might also have an invalid constant. To avoid making the
|
conservative assumption and requiring two reloads, we see if this address
|
conservative assumption and requiring two reloads, we see if this address
|
is valid when not interpreted strictly. If it is, the only problem is
|
is valid when not interpreted strictly. If it is, the only problem is
|
that the index needs a reload and find_reloads_address_1 will take care
|
that the index needs a reload and find_reloads_address_1 will take care
|
of it.
|
of it.
|
|
|
Handle all base registers here, not just fp/ap/sp, because on some
|
Handle all base registers here, not just fp/ap/sp, because on some
|
targets (namely SPARC) we can also get invalid addresses from preventive
|
targets (namely SPARC) we can also get invalid addresses from preventive
|
subreg big-endian corrections made by find_reloads_toplev. We
|
subreg big-endian corrections made by find_reloads_toplev. We
|
can also get expressions involving LO_SUM (rather than PLUS) from
|
can also get expressions involving LO_SUM (rather than PLUS) from
|
find_reloads_subreg_address.
|
find_reloads_subreg_address.
|
|
|
If we decide to do something, it must be that `double_reg_address_ok'
|
If we decide to do something, it must be that `double_reg_address_ok'
|
is true. We generate a reload of the base register + constant and
|
is true. We generate a reload of the base register + constant and
|
rework the sum so that the reload register will be added to the index.
|
rework the sum so that the reload register will be added to the index.
|
This is safe because we know the address isn't shared.
|
This is safe because we know the address isn't shared.
|
|
|
We check for the base register as both the first and second operand of
|
We check for the base register as both the first and second operand of
|
the innermost PLUS and/or LO_SUM. */
|
the innermost PLUS and/or LO_SUM. */
|
|
|
for (op_index = 0; op_index < 2; ++op_index)
|
for (op_index = 0; op_index < 2; ++op_index)
|
{
|
{
|
rtx operand, addend;
|
rtx operand, addend;
|
enum rtx_code inner_code;
|
enum rtx_code inner_code;
|
|
|
if (GET_CODE (ad) != PLUS)
|
if (GET_CODE (ad) != PLUS)
|
continue;
|
continue;
|
|
|
inner_code = GET_CODE (XEXP (ad, 0));
|
inner_code = GET_CODE (XEXP (ad, 0));
|
if (!(GET_CODE (ad) == PLUS
|
if (!(GET_CODE (ad) == PLUS
|
&& GET_CODE (XEXP (ad, 1)) == CONST_INT
|
&& GET_CODE (XEXP (ad, 1)) == CONST_INT
|
&& (inner_code == PLUS || inner_code == LO_SUM)))
|
&& (inner_code == PLUS || inner_code == LO_SUM)))
|
continue;
|
continue;
|
|
|
operand = XEXP (XEXP (ad, 0), op_index);
|
operand = XEXP (XEXP (ad, 0), op_index);
|
if (!REG_P (operand) || REGNO (operand) >= FIRST_PSEUDO_REGISTER)
|
if (!REG_P (operand) || REGNO (operand) >= FIRST_PSEUDO_REGISTER)
|
continue;
|
continue;
|
|
|
addend = XEXP (XEXP (ad, 0), 1 - op_index);
|
addend = XEXP (XEXP (ad, 0), 1 - op_index);
|
|
|
if ((regno_ok_for_base_p (REGNO (operand), mode, inner_code,
|
if ((regno_ok_for_base_p (REGNO (operand), mode, inner_code,
|
GET_CODE (addend))
|
GET_CODE (addend))
|
|| operand == frame_pointer_rtx
|
|| operand == frame_pointer_rtx
|
#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
|
#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
|
|| operand == hard_frame_pointer_rtx
|
|| operand == hard_frame_pointer_rtx
|
#endif
|
#endif
|
#if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
|
#if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
|
|| operand == arg_pointer_rtx
|
|| operand == arg_pointer_rtx
|
#endif
|
#endif
|
|| operand == stack_pointer_rtx)
|
|| operand == stack_pointer_rtx)
|
&& ! maybe_memory_address_p (mode, ad,
|
&& ! maybe_memory_address_p (mode, ad,
|
&XEXP (XEXP (ad, 0), 1 - op_index)))
|
&XEXP (XEXP (ad, 0), 1 - op_index)))
|
{
|
{
|
rtx offset_reg;
|
rtx offset_reg;
|
enum reg_class cls;
|
enum reg_class cls;
|
|
|
offset_reg = plus_constant (operand, INTVAL (XEXP (ad, 1)));
|
offset_reg = plus_constant (operand, INTVAL (XEXP (ad, 1)));
|
|
|
/* Form the adjusted address. */
|
/* Form the adjusted address. */
|
if (GET_CODE (XEXP (ad, 0)) == PLUS)
|
if (GET_CODE (XEXP (ad, 0)) == PLUS)
|
ad = gen_rtx_PLUS (GET_MODE (ad),
|
ad = gen_rtx_PLUS (GET_MODE (ad),
|
op_index == 0 ? offset_reg : addend,
|
op_index == 0 ? offset_reg : addend,
|
op_index == 0 ? addend : offset_reg);
|
op_index == 0 ? addend : offset_reg);
|
else
|
else
|
ad = gen_rtx_LO_SUM (GET_MODE (ad),
|
ad = gen_rtx_LO_SUM (GET_MODE (ad),
|
op_index == 0 ? offset_reg : addend,
|
op_index == 0 ? offset_reg : addend,
|
op_index == 0 ? addend : offset_reg);
|
op_index == 0 ? addend : offset_reg);
|
*loc = ad;
|
*loc = ad;
|
|
|
cls = base_reg_class (mode, MEM, GET_CODE (addend));
|
cls = base_reg_class (mode, MEM, GET_CODE (addend));
|
find_reloads_address_part (XEXP (ad, op_index),
|
find_reloads_address_part (XEXP (ad, op_index),
|
&XEXP (ad, op_index), cls,
|
&XEXP (ad, op_index), cls,
|
GET_MODE (ad), opnum, type, ind_levels);
|
GET_MODE (ad), opnum, type, ind_levels);
|
find_reloads_address_1 (mode,
|
find_reloads_address_1 (mode,
|
XEXP (ad, 1 - op_index), 1, GET_CODE (ad),
|
XEXP (ad, 1 - op_index), 1, GET_CODE (ad),
|
GET_CODE (XEXP (ad, op_index)),
|
GET_CODE (XEXP (ad, op_index)),
|
&XEXP (ad, 1 - op_index), opnum,
|
&XEXP (ad, 1 - op_index), opnum,
|
type, 0, insn);
|
type, 0, insn);
|
|
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
|
|
/* See if address becomes valid when an eliminable register
|
/* See if address becomes valid when an eliminable register
|
in a sum is replaced. */
|
in a sum is replaced. */
|
|
|
tem = ad;
|
tem = ad;
|
if (GET_CODE (ad) == PLUS)
|
if (GET_CODE (ad) == PLUS)
|
tem = subst_indexed_address (ad);
|
tem = subst_indexed_address (ad);
|
if (tem != ad && strict_memory_address_p (mode, tem))
|
if (tem != ad && strict_memory_address_p (mode, tem))
|
{
|
{
|
/* Ok, we win that way. Replace any additional eliminable
|
/* Ok, we win that way. Replace any additional eliminable
|
registers. */
|
registers. */
|
|
|
subst_reg_equivs_changed = 0;
|
subst_reg_equivs_changed = 0;
|
tem = subst_reg_equivs (tem, insn);
|
tem = subst_reg_equivs (tem, insn);
|
|
|
/* Make sure that didn't make the address invalid again. */
|
/* Make sure that didn't make the address invalid again. */
|
|
|
if (! subst_reg_equivs_changed || strict_memory_address_p (mode, tem))
|
if (! subst_reg_equivs_changed || strict_memory_address_p (mode, tem))
|
{
|
{
|
*loc = tem;
|
*loc = tem;
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
|
|
/* If constants aren't valid addresses, reload the constant address
|
/* If constants aren't valid addresses, reload the constant address
|
into a register. */
|
into a register. */
|
if (CONSTANT_P (ad) && ! strict_memory_address_p (mode, ad))
|
if (CONSTANT_P (ad) && ! strict_memory_address_p (mode, ad))
|
{
|
{
|
/* If AD is an address in the constant pool, the MEM rtx may be shared.
|
/* If AD is an address in the constant pool, the MEM rtx may be shared.
|
Unshare it so we can safely alter it. */
|
Unshare it so we can safely alter it. */
|
if (memrefloc && GET_CODE (ad) == SYMBOL_REF
|
if (memrefloc && GET_CODE (ad) == SYMBOL_REF
|
&& CONSTANT_POOL_ADDRESS_P (ad))
|
&& CONSTANT_POOL_ADDRESS_P (ad))
|
{
|
{
|
*memrefloc = copy_rtx (*memrefloc);
|
*memrefloc = copy_rtx (*memrefloc);
|
loc = &XEXP (*memrefloc, 0);
|
loc = &XEXP (*memrefloc, 0);
|
if (removed_and)
|
if (removed_and)
|
loc = &XEXP (*loc, 0);
|
loc = &XEXP (*loc, 0);
|
}
|
}
|
|
|
find_reloads_address_part (ad, loc, base_reg_class (mode, MEM, SCRATCH),
|
find_reloads_address_part (ad, loc, base_reg_class (mode, MEM, SCRATCH),
|
Pmode, opnum, type, ind_levels);
|
Pmode, opnum, type, ind_levels);
|
return ! removed_and;
|
return ! removed_and;
|
}
|
}
|
|
|
return find_reloads_address_1 (mode, ad, 0, MEM, SCRATCH, loc, opnum, type,
|
return find_reloads_address_1 (mode, ad, 0, MEM, SCRATCH, loc, opnum, type,
|
ind_levels, insn);
|
ind_levels, insn);
|
}
|
}
|
|
|
/* Find all pseudo regs appearing in AD
|
/* Find all pseudo regs appearing in AD
|
that are eliminable in favor of equivalent values
|
that are eliminable in favor of equivalent values
|
and do not have hard regs; replace them by their equivalents.
|
and do not have hard regs; replace them by their equivalents.
|
INSN, if nonzero, is the insn in which we do the reload. We put USEs in
|
INSN, if nonzero, is the insn in which we do the reload. We put USEs in
|
front of it for pseudos that we have to replace with stack slots. */
|
front of it for pseudos that we have to replace with stack slots. */
|
|
|
static rtx
|
static rtx
|
subst_reg_equivs (rtx ad, rtx insn)
|
subst_reg_equivs (rtx ad, rtx insn)
|
{
|
{
|
RTX_CODE code = GET_CODE (ad);
|
RTX_CODE code = GET_CODE (ad);
|
int i;
|
int i;
|
const char *fmt;
|
const char *fmt;
|
|
|
switch (code)
|
switch (code)
|
{
|
{
|
case HIGH:
|
case HIGH:
|
case CONST_INT:
|
case CONST_INT:
|
case CONST:
|
case CONST:
|
case CONST_DOUBLE:
|
case CONST_DOUBLE:
|
case CONST_VECTOR:
|
case CONST_VECTOR:
|
case SYMBOL_REF:
|
case SYMBOL_REF:
|
case LABEL_REF:
|
case LABEL_REF:
|
case PC:
|
case PC:
|
case CC0:
|
case CC0:
|
return ad;
|
return ad;
|
|
|
case REG:
|
case REG:
|
{
|
{
|
int regno = REGNO (ad);
|
int regno = REGNO (ad);
|
|
|
if (reg_equiv_constant[regno] != 0)
|
if (reg_equiv_constant[regno] != 0)
|
{
|
{
|
subst_reg_equivs_changed = 1;
|
subst_reg_equivs_changed = 1;
|
return reg_equiv_constant[regno];
|
return reg_equiv_constant[regno];
|
}
|
}
|
if (reg_equiv_memory_loc[regno] && num_not_at_initial_offset)
|
if (reg_equiv_memory_loc[regno] && num_not_at_initial_offset)
|
{
|
{
|
rtx mem = make_memloc (ad, regno);
|
rtx mem = make_memloc (ad, regno);
|
if (! rtx_equal_p (mem, reg_equiv_mem[regno]))
|
if (! rtx_equal_p (mem, reg_equiv_mem[regno]))
|
{
|
{
|
subst_reg_equivs_changed = 1;
|
subst_reg_equivs_changed = 1;
|
/* We mark the USE with QImode so that we recognize it
|
/* We mark the USE with QImode so that we recognize it
|
as one that can be safely deleted at the end of
|
as one that can be safely deleted at the end of
|
reload. */
|
reload. */
|
PUT_MODE (emit_insn_before (gen_rtx_USE (VOIDmode, ad), insn),
|
PUT_MODE (emit_insn_before (gen_rtx_USE (VOIDmode, ad), insn),
|
QImode);
|
QImode);
|
return mem;
|
return mem;
|
}
|
}
|
}
|
}
|
}
|
}
|
return ad;
|
return ad;
|
|
|
case PLUS:
|
case PLUS:
|
/* Quickly dispose of a common case. */
|
/* Quickly dispose of a common case. */
|
if (XEXP (ad, 0) == frame_pointer_rtx
|
if (XEXP (ad, 0) == frame_pointer_rtx
|
&& GET_CODE (XEXP (ad, 1)) == CONST_INT)
|
&& GET_CODE (XEXP (ad, 1)) == CONST_INT)
|
return ad;
|
return ad;
|
break;
|
break;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
fmt = GET_RTX_FORMAT (code);
|
fmt = GET_RTX_FORMAT (code);
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
if (fmt[i] == 'e')
|
if (fmt[i] == 'e')
|
XEXP (ad, i) = subst_reg_equivs (XEXP (ad, i), insn);
|
XEXP (ad, i) = subst_reg_equivs (XEXP (ad, i), insn);
|
return ad;
|
return ad;
|
}
|
}
|
|
|
/* Compute the sum of X and Y, making canonicalizations assumed in an
|
/* Compute the sum of X and Y, making canonicalizations assumed in an
|
address, namely: sum constant integers, surround the sum of two
|
address, namely: sum constant integers, surround the sum of two
|
constants with a CONST, put the constant as the second operand, and
|
constants with a CONST, put the constant as the second operand, and
|
group the constant on the outermost sum.
|
group the constant on the outermost sum.
|
|
|
This routine assumes both inputs are already in canonical form. */
|
This routine assumes both inputs are already in canonical form. */
|
|
|
rtx
|
rtx
|
form_sum (rtx x, rtx y)
|
form_sum (rtx x, rtx y)
|
{
|
{
|
rtx tem;
|
rtx tem;
|
enum machine_mode mode = GET_MODE (x);
|
enum machine_mode mode = GET_MODE (x);
|
|
|
if (mode == VOIDmode)
|
if (mode == VOIDmode)
|
mode = GET_MODE (y);
|
mode = GET_MODE (y);
|
|
|
if (mode == VOIDmode)
|
if (mode == VOIDmode)
|
mode = Pmode;
|
mode = Pmode;
|
|
|
if (GET_CODE (x) == CONST_INT)
|
if (GET_CODE (x) == CONST_INT)
|
return plus_constant (y, INTVAL (x));
|
return plus_constant (y, INTVAL (x));
|
else if (GET_CODE (y) == CONST_INT)
|
else if (GET_CODE (y) == CONST_INT)
|
return plus_constant (x, INTVAL (y));
|
return plus_constant (x, INTVAL (y));
|
else if (CONSTANT_P (x))
|
else if (CONSTANT_P (x))
|
tem = x, x = y, y = tem;
|
tem = x, x = y, y = tem;
|
|
|
if (GET_CODE (x) == PLUS && CONSTANT_P (XEXP (x, 1)))
|
if (GET_CODE (x) == PLUS && CONSTANT_P (XEXP (x, 1)))
|
return form_sum (XEXP (x, 0), form_sum (XEXP (x, 1), y));
|
return form_sum (XEXP (x, 0), form_sum (XEXP (x, 1), y));
|
|
|
/* Note that if the operands of Y are specified in the opposite
|
/* Note that if the operands of Y are specified in the opposite
|
order in the recursive calls below, infinite recursion will occur. */
|
order in the recursive calls below, infinite recursion will occur. */
|
if (GET_CODE (y) == PLUS && CONSTANT_P (XEXP (y, 1)))
|
if (GET_CODE (y) == PLUS && CONSTANT_P (XEXP (y, 1)))
|
return form_sum (form_sum (x, XEXP (y, 0)), XEXP (y, 1));
|
return form_sum (form_sum (x, XEXP (y, 0)), XEXP (y, 1));
|
|
|
/* If both constant, encapsulate sum. Otherwise, just form sum. A
|
/* If both constant, encapsulate sum. Otherwise, just form sum. A
|
constant will have been placed second. */
|
constant will have been placed second. */
|
if (CONSTANT_P (x) && CONSTANT_P (y))
|
if (CONSTANT_P (x) && CONSTANT_P (y))
|
{
|
{
|
if (GET_CODE (x) == CONST)
|
if (GET_CODE (x) == CONST)
|
x = XEXP (x, 0);
|
x = XEXP (x, 0);
|
if (GET_CODE (y) == CONST)
|
if (GET_CODE (y) == CONST)
|
y = XEXP (y, 0);
|
y = XEXP (y, 0);
|
|
|
return gen_rtx_CONST (VOIDmode, gen_rtx_PLUS (mode, x, y));
|
return gen_rtx_CONST (VOIDmode, gen_rtx_PLUS (mode, x, y));
|
}
|
}
|
|
|
return gen_rtx_PLUS (mode, x, y);
|
return gen_rtx_PLUS (mode, x, y);
|
}
|
}
|
|
|
/* If ADDR is a sum containing a pseudo register that should be
|
/* If ADDR is a sum containing a pseudo register that should be
|
replaced with a constant (from reg_equiv_constant),
|
replaced with a constant (from reg_equiv_constant),
|
return the result of doing so, and also apply the associative
|
return the result of doing so, and also apply the associative
|
law so that the result is more likely to be a valid address.
|
law so that the result is more likely to be a valid address.
|
(But it is not guaranteed to be one.)
|
(But it is not guaranteed to be one.)
|
|
|
Note that at most one register is replaced, even if more are
|
Note that at most one register is replaced, even if more are
|
replaceable. Also, we try to put the result into a canonical form
|
replaceable. Also, we try to put the result into a canonical form
|
so it is more likely to be a valid address.
|
so it is more likely to be a valid address.
|
|
|
In all other cases, return ADDR. */
|
In all other cases, return ADDR. */
|
|
|
static rtx
|
static rtx
|
subst_indexed_address (rtx addr)
|
subst_indexed_address (rtx addr)
|
{
|
{
|
rtx op0 = 0, op1 = 0, op2 = 0;
|
rtx op0 = 0, op1 = 0, op2 = 0;
|
rtx tem;
|
rtx tem;
|
int regno;
|
int regno;
|
|
|
if (GET_CODE (addr) == PLUS)
|
if (GET_CODE (addr) == PLUS)
|
{
|
{
|
/* Try to find a register to replace. */
|
/* Try to find a register to replace. */
|
op0 = XEXP (addr, 0), op1 = XEXP (addr, 1), op2 = 0;
|
op0 = XEXP (addr, 0), op1 = XEXP (addr, 1), op2 = 0;
|
if (REG_P (op0)
|
if (REG_P (op0)
|
&& (regno = REGNO (op0)) >= FIRST_PSEUDO_REGISTER
|
&& (regno = REGNO (op0)) >= FIRST_PSEUDO_REGISTER
|
&& reg_renumber[regno] < 0
|
&& reg_renumber[regno] < 0
|
&& reg_equiv_constant[regno] != 0)
|
&& reg_equiv_constant[regno] != 0)
|
op0 = reg_equiv_constant[regno];
|
op0 = reg_equiv_constant[regno];
|
else if (REG_P (op1)
|
else if (REG_P (op1)
|
&& (regno = REGNO (op1)) >= FIRST_PSEUDO_REGISTER
|
&& (regno = REGNO (op1)) >= FIRST_PSEUDO_REGISTER
|
&& reg_renumber[regno] < 0
|
&& reg_renumber[regno] < 0
|
&& reg_equiv_constant[regno] != 0)
|
&& reg_equiv_constant[regno] != 0)
|
op1 = reg_equiv_constant[regno];
|
op1 = reg_equiv_constant[regno];
|
else if (GET_CODE (op0) == PLUS
|
else if (GET_CODE (op0) == PLUS
|
&& (tem = subst_indexed_address (op0)) != op0)
|
&& (tem = subst_indexed_address (op0)) != op0)
|
op0 = tem;
|
op0 = tem;
|
else if (GET_CODE (op1) == PLUS
|
else if (GET_CODE (op1) == PLUS
|
&& (tem = subst_indexed_address (op1)) != op1)
|
&& (tem = subst_indexed_address (op1)) != op1)
|
op1 = tem;
|
op1 = tem;
|
else
|
else
|
return addr;
|
return addr;
|
|
|
/* Pick out up to three things to add. */
|
/* Pick out up to three things to add. */
|
if (GET_CODE (op1) == PLUS)
|
if (GET_CODE (op1) == PLUS)
|
op2 = XEXP (op1, 1), op1 = XEXP (op1, 0);
|
op2 = XEXP (op1, 1), op1 = XEXP (op1, 0);
|
else if (GET_CODE (op0) == PLUS)
|
else if (GET_CODE (op0) == PLUS)
|
op2 = op1, op1 = XEXP (op0, 1), op0 = XEXP (op0, 0);
|
op2 = op1, op1 = XEXP (op0, 1), op0 = XEXP (op0, 0);
|
|
|
/* Compute the sum. */
|
/* Compute the sum. */
|
if (op2 != 0)
|
if (op2 != 0)
|
op1 = form_sum (op1, op2);
|
op1 = form_sum (op1, op2);
|
if (op1 != 0)
|
if (op1 != 0)
|
op0 = form_sum (op0, op1);
|
op0 = form_sum (op0, op1);
|
|
|
return op0;
|
return op0;
|
}
|
}
|
return addr;
|
return addr;
|
}
|
}
|
|
|
/* Update the REG_INC notes for an insn. It updates all REG_INC
|
/* Update the REG_INC notes for an insn. It updates all REG_INC
|
notes for the instruction which refer to REGNO the to refer
|
notes for the instruction which refer to REGNO the to refer
|
to the reload number.
|
to the reload number.
|
|
|
INSN is the insn for which any REG_INC notes need updating.
|
INSN is the insn for which any REG_INC notes need updating.
|
|
|
REGNO is the register number which has been reloaded.
|
REGNO is the register number which has been reloaded.
|
|
|
RELOADNUM is the reload number. */
|
RELOADNUM is the reload number. */
|
|
|
static void
|
static void
|
update_auto_inc_notes (rtx insn ATTRIBUTE_UNUSED, int regno ATTRIBUTE_UNUSED,
|
update_auto_inc_notes (rtx insn ATTRIBUTE_UNUSED, int regno ATTRIBUTE_UNUSED,
|
int reloadnum ATTRIBUTE_UNUSED)
|
int reloadnum ATTRIBUTE_UNUSED)
|
{
|
{
|
#ifdef AUTO_INC_DEC
|
#ifdef AUTO_INC_DEC
|
rtx link;
|
rtx link;
|
|
|
for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
|
for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
|
if (REG_NOTE_KIND (link) == REG_INC
|
if (REG_NOTE_KIND (link) == REG_INC
|
&& (int) REGNO (XEXP (link, 0)) == regno)
|
&& (int) REGNO (XEXP (link, 0)) == regno)
|
push_replacement (&XEXP (link, 0), reloadnum, VOIDmode);
|
push_replacement (&XEXP (link, 0), reloadnum, VOIDmode);
|
#endif
|
#endif
|
}
|
}
|
|
|
/* Record the pseudo registers we must reload into hard registers in a
|
/* Record the pseudo registers we must reload into hard registers in a
|
subexpression of a would-be memory address, X referring to a value
|
subexpression of a would-be memory address, X referring to a value
|
in mode MODE. (This function is not called if the address we find
|
in mode MODE. (This function is not called if the address we find
|
is strictly valid.)
|
is strictly valid.)
|
|
|
CONTEXT = 1 means we are considering regs as index regs,
|
CONTEXT = 1 means we are considering regs as index regs,
|
= 0 means we are considering them as base regs.
|
= 0 means we are considering them as base regs.
|
OUTER_CODE is the code of the enclosing RTX, typically a MEM, a PLUS,
|
OUTER_CODE is the code of the enclosing RTX, typically a MEM, a PLUS,
|
or an autoinc code.
|
or an autoinc code.
|
If CONTEXT == 0 and OUTER_CODE is a PLUS or LO_SUM, then INDEX_CODE
|
If CONTEXT == 0 and OUTER_CODE is a PLUS or LO_SUM, then INDEX_CODE
|
is the code of the index part of the address. Otherwise, pass SCRATCH
|
is the code of the index part of the address. Otherwise, pass SCRATCH
|
for this argument.
|
for this argument.
|
OPNUM and TYPE specify the purpose of any reloads made.
|
OPNUM and TYPE specify the purpose of any reloads made.
|
|
|
IND_LEVELS says how many levels of indirect addressing are
|
IND_LEVELS says how many levels of indirect addressing are
|
supported at this point in the address.
|
supported at this point in the address.
|
|
|
INSN, if nonzero, is the insn in which we do the reload. It is used
|
INSN, if nonzero, is the insn in which we do the reload. It is used
|
to determine if we may generate output reloads.
|
to determine if we may generate output reloads.
|
|
|
We return nonzero if X, as a whole, is reloaded or replaced. */
|
We return nonzero if X, as a whole, is reloaded or replaced. */
|
|
|
/* Note that we take shortcuts assuming that no multi-reg machine mode
|
/* Note that we take shortcuts assuming that no multi-reg machine mode
|
occurs as part of an address.
|
occurs as part of an address.
|
Also, this is not fully machine-customizable; it works for machines
|
Also, this is not fully machine-customizable; it works for machines
|
such as VAXen and 68000's and 32000's, but other possible machines
|
such as VAXen and 68000's and 32000's, but other possible machines
|
could have addressing modes that this does not handle right.
|
could have addressing modes that this does not handle right.
|
If you add push_reload calls here, you need to make sure gen_reload
|
If you add push_reload calls here, you need to make sure gen_reload
|
handles those cases gracefully. */
|
handles those cases gracefully. */
|
|
|
static int
|
static int
|
find_reloads_address_1 (enum machine_mode mode, rtx x, int context,
|
find_reloads_address_1 (enum machine_mode mode, rtx x, int context,
|
enum rtx_code outer_code, enum rtx_code index_code,
|
enum rtx_code outer_code, enum rtx_code index_code,
|
rtx *loc, int opnum, enum reload_type type,
|
rtx *loc, int opnum, enum reload_type type,
|
int ind_levels, rtx insn)
|
int ind_levels, rtx insn)
|
{
|
{
|
#define REG_OK_FOR_CONTEXT(CONTEXT, REGNO, MODE, OUTER, INDEX) \
|
#define REG_OK_FOR_CONTEXT(CONTEXT, REGNO, MODE, OUTER, INDEX) \
|
((CONTEXT) == 0 \
|
((CONTEXT) == 0 \
|
? regno_ok_for_base_p (REGNO, MODE, OUTER, INDEX) \
|
? regno_ok_for_base_p (REGNO, MODE, OUTER, INDEX) \
|
: REGNO_OK_FOR_INDEX_P (REGNO))
|
: REGNO_OK_FOR_INDEX_P (REGNO))
|
|
|
enum reg_class context_reg_class;
|
enum reg_class context_reg_class;
|
RTX_CODE code = GET_CODE (x);
|
RTX_CODE code = GET_CODE (x);
|
|
|
if (context == 1)
|
if (context == 1)
|
context_reg_class = INDEX_REG_CLASS;
|
context_reg_class = INDEX_REG_CLASS;
|
else
|
else
|
context_reg_class = base_reg_class (mode, outer_code, index_code);
|
context_reg_class = base_reg_class (mode, outer_code, index_code);
|
|
|
switch (code)
|
switch (code)
|
{
|
{
|
case PLUS:
|
case PLUS:
|
{
|
{
|
rtx orig_op0 = XEXP (x, 0);
|
rtx orig_op0 = XEXP (x, 0);
|
rtx orig_op1 = XEXP (x, 1);
|
rtx orig_op1 = XEXP (x, 1);
|
RTX_CODE code0 = GET_CODE (orig_op0);
|
RTX_CODE code0 = GET_CODE (orig_op0);
|
RTX_CODE code1 = GET_CODE (orig_op1);
|
RTX_CODE code1 = GET_CODE (orig_op1);
|
rtx op0 = orig_op0;
|
rtx op0 = orig_op0;
|
rtx op1 = orig_op1;
|
rtx op1 = orig_op1;
|
|
|
if (GET_CODE (op0) == SUBREG)
|
if (GET_CODE (op0) == SUBREG)
|
{
|
{
|
op0 = SUBREG_REG (op0);
|
op0 = SUBREG_REG (op0);
|
code0 = GET_CODE (op0);
|
code0 = GET_CODE (op0);
|
if (code0 == REG && REGNO (op0) < FIRST_PSEUDO_REGISTER)
|
if (code0 == REG && REGNO (op0) < FIRST_PSEUDO_REGISTER)
|
op0 = gen_rtx_REG (word_mode,
|
op0 = gen_rtx_REG (word_mode,
|
(REGNO (op0) +
|
(REGNO (op0) +
|
subreg_regno_offset (REGNO (SUBREG_REG (orig_op0)),
|
subreg_regno_offset (REGNO (SUBREG_REG (orig_op0)),
|
GET_MODE (SUBREG_REG (orig_op0)),
|
GET_MODE (SUBREG_REG (orig_op0)),
|
SUBREG_BYTE (orig_op0),
|
SUBREG_BYTE (orig_op0),
|
GET_MODE (orig_op0))));
|
GET_MODE (orig_op0))));
|
}
|
}
|
|
|
if (GET_CODE (op1) == SUBREG)
|
if (GET_CODE (op1) == SUBREG)
|
{
|
{
|
op1 = SUBREG_REG (op1);
|
op1 = SUBREG_REG (op1);
|
code1 = GET_CODE (op1);
|
code1 = GET_CODE (op1);
|
if (code1 == REG && REGNO (op1) < FIRST_PSEUDO_REGISTER)
|
if (code1 == REG && REGNO (op1) < FIRST_PSEUDO_REGISTER)
|
/* ??? Why is this given op1's mode and above for
|
/* ??? Why is this given op1's mode and above for
|
??? op0 SUBREGs we use word_mode? */
|
??? op0 SUBREGs we use word_mode? */
|
op1 = gen_rtx_REG (GET_MODE (op1),
|
op1 = gen_rtx_REG (GET_MODE (op1),
|
(REGNO (op1) +
|
(REGNO (op1) +
|
subreg_regno_offset (REGNO (SUBREG_REG (orig_op1)),
|
subreg_regno_offset (REGNO (SUBREG_REG (orig_op1)),
|
GET_MODE (SUBREG_REG (orig_op1)),
|
GET_MODE (SUBREG_REG (orig_op1)),
|
SUBREG_BYTE (orig_op1),
|
SUBREG_BYTE (orig_op1),
|
GET_MODE (orig_op1))));
|
GET_MODE (orig_op1))));
|
}
|
}
|
/* Plus in the index register may be created only as a result of
|
/* Plus in the index register may be created only as a result of
|
register rematerialization for expression like &localvar*4. Reload it.
|
register rematerialization for expression like &localvar*4. Reload it.
|
It may be possible to combine the displacement on the outer level,
|
It may be possible to combine the displacement on the outer level,
|
but it is probably not worthwhile to do so. */
|
but it is probably not worthwhile to do so. */
|
if (context == 1)
|
if (context == 1)
|
{
|
{
|
find_reloads_address (GET_MODE (x), loc, XEXP (x, 0), &XEXP (x, 0),
|
find_reloads_address (GET_MODE (x), loc, XEXP (x, 0), &XEXP (x, 0),
|
opnum, ADDR_TYPE (type), ind_levels, insn);
|
opnum, ADDR_TYPE (type), ind_levels, insn);
|
push_reload (*loc, NULL_RTX, loc, (rtx*) 0,
|
push_reload (*loc, NULL_RTX, loc, (rtx*) 0,
|
context_reg_class,
|
context_reg_class,
|
GET_MODE (x), VOIDmode, 0, 0, opnum, type);
|
GET_MODE (x), VOIDmode, 0, 0, opnum, type);
|
return 1;
|
return 1;
|
}
|
}
|
|
|
if (code0 == MULT || code0 == SIGN_EXTEND || code0 == TRUNCATE
|
if (code0 == MULT || code0 == SIGN_EXTEND || code0 == TRUNCATE
|
|| code0 == ZERO_EXTEND || code1 == MEM)
|
|| code0 == ZERO_EXTEND || code1 == MEM)
|
{
|
{
|
find_reloads_address_1 (mode, orig_op0, 1, PLUS, SCRATCH,
|
find_reloads_address_1 (mode, orig_op0, 1, PLUS, SCRATCH,
|
&XEXP (x, 0), opnum, type, ind_levels,
|
&XEXP (x, 0), opnum, type, ind_levels,
|
insn);
|
insn);
|
find_reloads_address_1 (mode, orig_op1, 0, PLUS, code0,
|
find_reloads_address_1 (mode, orig_op1, 0, PLUS, code0,
|
&XEXP (x, 1), opnum, type, ind_levels,
|
&XEXP (x, 1), opnum, type, ind_levels,
|
insn);
|
insn);
|
}
|
}
|
|
|
else if (code1 == MULT || code1 == SIGN_EXTEND || code1 == TRUNCATE
|
else if (code1 == MULT || code1 == SIGN_EXTEND || code1 == TRUNCATE
|
|| code1 == ZERO_EXTEND || code0 == MEM)
|
|| code1 == ZERO_EXTEND || code0 == MEM)
|
{
|
{
|
find_reloads_address_1 (mode, orig_op0, 0, PLUS, code1,
|
find_reloads_address_1 (mode, orig_op0, 0, PLUS, code1,
|
&XEXP (x, 0), opnum, type, ind_levels,
|
&XEXP (x, 0), opnum, type, ind_levels,
|
insn);
|
insn);
|
find_reloads_address_1 (mode, orig_op1, 1, PLUS, SCRATCH,
|
find_reloads_address_1 (mode, orig_op1, 1, PLUS, SCRATCH,
|
&XEXP (x, 1), opnum, type, ind_levels,
|
&XEXP (x, 1), opnum, type, ind_levels,
|
insn);
|
insn);
|
}
|
}
|
|
|
else if (code0 == CONST_INT || code0 == CONST
|
else if (code0 == CONST_INT || code0 == CONST
|
|| code0 == SYMBOL_REF || code0 == LABEL_REF)
|
|| code0 == SYMBOL_REF || code0 == LABEL_REF)
|
find_reloads_address_1 (mode, orig_op1, 0, PLUS, code0,
|
find_reloads_address_1 (mode, orig_op1, 0, PLUS, code0,
|
&XEXP (x, 1), opnum, type, ind_levels,
|
&XEXP (x, 1), opnum, type, ind_levels,
|
insn);
|
insn);
|
|
|
else if (code1 == CONST_INT || code1 == CONST
|
else if (code1 == CONST_INT || code1 == CONST
|
|| code1 == SYMBOL_REF || code1 == LABEL_REF)
|
|| code1 == SYMBOL_REF || code1 == LABEL_REF)
|
find_reloads_address_1 (mode, orig_op0, 0, PLUS, code1,
|
find_reloads_address_1 (mode, orig_op0, 0, PLUS, code1,
|
&XEXP (x, 0), opnum, type, ind_levels,
|
&XEXP (x, 0), opnum, type, ind_levels,
|
insn);
|
insn);
|
|
|
else if (code0 == REG && code1 == REG)
|
else if (code0 == REG && code1 == REG)
|
{
|
{
|
if (REGNO_OK_FOR_INDEX_P (REGNO (op0))
|
if (REGNO_OK_FOR_INDEX_P (REGNO (op0))
|
&& regno_ok_for_base_p (REGNO (op1), mode, PLUS, REG))
|
&& regno_ok_for_base_p (REGNO (op1), mode, PLUS, REG))
|
return 0;
|
return 0;
|
else if (REGNO_OK_FOR_INDEX_P (REGNO (op1))
|
else if (REGNO_OK_FOR_INDEX_P (REGNO (op1))
|
&& regno_ok_for_base_p (REGNO (op0), mode, PLUS, REG))
|
&& regno_ok_for_base_p (REGNO (op0), mode, PLUS, REG))
|
return 0;
|
return 0;
|
else if (regno_ok_for_base_p (REGNO (op1), mode, PLUS, REG))
|
else if (regno_ok_for_base_p (REGNO (op1), mode, PLUS, REG))
|
find_reloads_address_1 (mode, orig_op0, 1, PLUS, SCRATCH,
|
find_reloads_address_1 (mode, orig_op0, 1, PLUS, SCRATCH,
|
&XEXP (x, 0), opnum, type, ind_levels,
|
&XEXP (x, 0), opnum, type, ind_levels,
|
insn);
|
insn);
|
else if (regno_ok_for_base_p (REGNO (op0), mode, PLUS, REG))
|
else if (regno_ok_for_base_p (REGNO (op0), mode, PLUS, REG))
|
find_reloads_address_1 (mode, orig_op1, 1, PLUS, SCRATCH,
|
find_reloads_address_1 (mode, orig_op1, 1, PLUS, SCRATCH,
|
&XEXP (x, 1), opnum, type, ind_levels,
|
&XEXP (x, 1), opnum, type, ind_levels,
|
insn);
|
insn);
|
else if (REGNO_OK_FOR_INDEX_P (REGNO (op1)))
|
else if (REGNO_OK_FOR_INDEX_P (REGNO (op1)))
|
find_reloads_address_1 (mode, orig_op0, 0, PLUS, REG,
|
find_reloads_address_1 (mode, orig_op0, 0, PLUS, REG,
|
&XEXP (x, 0), opnum, type, ind_levels,
|
&XEXP (x, 0), opnum, type, ind_levels,
|
insn);
|
insn);
|
else if (REGNO_OK_FOR_INDEX_P (REGNO (op0)))
|
else if (REGNO_OK_FOR_INDEX_P (REGNO (op0)))
|
find_reloads_address_1 (mode, orig_op1, 0, PLUS, REG,
|
find_reloads_address_1 (mode, orig_op1, 0, PLUS, REG,
|
&XEXP (x, 1), opnum, type, ind_levels,
|
&XEXP (x, 1), opnum, type, ind_levels,
|
insn);
|
insn);
|
else
|
else
|
{
|
{
|
find_reloads_address_1 (mode, orig_op0, 1, PLUS, SCRATCH,
|
find_reloads_address_1 (mode, orig_op0, 1, PLUS, SCRATCH,
|
&XEXP (x, 0), opnum, type, ind_levels,
|
&XEXP (x, 0), opnum, type, ind_levels,
|
insn);
|
insn);
|
find_reloads_address_1 (mode, orig_op1, 0, PLUS, REG,
|
find_reloads_address_1 (mode, orig_op1, 0, PLUS, REG,
|
&XEXP (x, 1), opnum, type, ind_levels,
|
&XEXP (x, 1), opnum, type, ind_levels,
|
insn);
|
insn);
|
}
|
}
|
}
|
}
|
|
|
else if (code0 == REG)
|
else if (code0 == REG)
|
{
|
{
|
find_reloads_address_1 (mode, orig_op0, 1, PLUS, SCRATCH,
|
find_reloads_address_1 (mode, orig_op0, 1, PLUS, SCRATCH,
|
&XEXP (x, 0), opnum, type, ind_levels,
|
&XEXP (x, 0), opnum, type, ind_levels,
|
insn);
|
insn);
|
find_reloads_address_1 (mode, orig_op1, 0, PLUS, REG,
|
find_reloads_address_1 (mode, orig_op1, 0, PLUS, REG,
|
&XEXP (x, 1), opnum, type, ind_levels,
|
&XEXP (x, 1), opnum, type, ind_levels,
|
insn);
|
insn);
|
}
|
}
|
|
|
else if (code1 == REG)
|
else if (code1 == REG)
|
{
|
{
|
find_reloads_address_1 (mode, orig_op1, 1, PLUS, SCRATCH,
|
find_reloads_address_1 (mode, orig_op1, 1, PLUS, SCRATCH,
|
&XEXP (x, 1), opnum, type, ind_levels,
|
&XEXP (x, 1), opnum, type, ind_levels,
|
insn);
|
insn);
|
find_reloads_address_1 (mode, orig_op0, 0, PLUS, REG,
|
find_reloads_address_1 (mode, orig_op0, 0, PLUS, REG,
|
&XEXP (x, 0), opnum, type, ind_levels,
|
&XEXP (x, 0), opnum, type, ind_levels,
|
insn);
|
insn);
|
}
|
}
|
}
|
}
|
|
|
return 0;
|
return 0;
|
|
|
case POST_MODIFY:
|
case POST_MODIFY:
|
case PRE_MODIFY:
|
case PRE_MODIFY:
|
{
|
{
|
rtx op0 = XEXP (x, 0);
|
rtx op0 = XEXP (x, 0);
|
rtx op1 = XEXP (x, 1);
|
rtx op1 = XEXP (x, 1);
|
enum rtx_code index_code;
|
enum rtx_code index_code;
|
int regno;
|
int regno;
|
int reloadnum;
|
int reloadnum;
|
|
|
if (GET_CODE (op1) != PLUS && GET_CODE (op1) != MINUS)
|
if (GET_CODE (op1) != PLUS && GET_CODE (op1) != MINUS)
|
return 0;
|
return 0;
|
|
|
/* Currently, we only support {PRE,POST}_MODIFY constructs
|
/* Currently, we only support {PRE,POST}_MODIFY constructs
|
where a base register is {inc,dec}remented by the contents
|
where a base register is {inc,dec}remented by the contents
|
of another register or by a constant value. Thus, these
|
of another register or by a constant value. Thus, these
|
operands must match. */
|
operands must match. */
|
gcc_assert (op0 == XEXP (op1, 0));
|
gcc_assert (op0 == XEXP (op1, 0));
|
|
|
/* Require index register (or constant). Let's just handle the
|
/* Require index register (or constant). Let's just handle the
|
register case in the meantime... If the target allows
|
register case in the meantime... If the target allows
|
auto-modify by a constant then we could try replacing a pseudo
|
auto-modify by a constant then we could try replacing a pseudo
|
register with its equivalent constant where applicable.
|
register with its equivalent constant where applicable.
|
|
|
If we later decide to reload the whole PRE_MODIFY or
|
If we later decide to reload the whole PRE_MODIFY or
|
POST_MODIFY, inc_for_reload might clobber the reload register
|
POST_MODIFY, inc_for_reload might clobber the reload register
|
before reading the index. The index register might therefore
|
before reading the index. The index register might therefore
|
need to live longer than a TYPE reload normally would, so be
|
need to live longer than a TYPE reload normally would, so be
|
conservative and class it as RELOAD_OTHER. */
|
conservative and class it as RELOAD_OTHER. */
|
if (REG_P (XEXP (op1, 1)))
|
if (REG_P (XEXP (op1, 1)))
|
if (!REGNO_OK_FOR_INDEX_P (REGNO (XEXP (op1, 1))))
|
if (!REGNO_OK_FOR_INDEX_P (REGNO (XEXP (op1, 1))))
|
find_reloads_address_1 (mode, XEXP (op1, 1), 1, code, SCRATCH,
|
find_reloads_address_1 (mode, XEXP (op1, 1), 1, code, SCRATCH,
|
&XEXP (op1, 1), opnum, RELOAD_OTHER,
|
&XEXP (op1, 1), opnum, RELOAD_OTHER,
|
ind_levels, insn);
|
ind_levels, insn);
|
|
|
gcc_assert (REG_P (XEXP (op1, 0)));
|
gcc_assert (REG_P (XEXP (op1, 0)));
|
|
|
regno = REGNO (XEXP (op1, 0));
|
regno = REGNO (XEXP (op1, 0));
|
index_code = GET_CODE (XEXP (op1, 1));
|
index_code = GET_CODE (XEXP (op1, 1));
|
|
|
/* A register that is incremented cannot be constant! */
|
/* A register that is incremented cannot be constant! */
|
gcc_assert (regno < FIRST_PSEUDO_REGISTER
|
gcc_assert (regno < FIRST_PSEUDO_REGISTER
|
|| reg_equiv_constant[regno] == 0);
|
|| reg_equiv_constant[regno] == 0);
|
|
|
/* Handle a register that is equivalent to a memory location
|
/* Handle a register that is equivalent to a memory location
|
which cannot be addressed directly. */
|
which cannot be addressed directly. */
|
if (reg_equiv_memory_loc[regno] != 0
|
if (reg_equiv_memory_loc[regno] != 0
|
&& (reg_equiv_address[regno] != 0
|
&& (reg_equiv_address[regno] != 0
|
|| num_not_at_initial_offset))
|
|| num_not_at_initial_offset))
|
{
|
{
|
rtx tem = make_memloc (XEXP (x, 0), regno);
|
rtx tem = make_memloc (XEXP (x, 0), regno);
|
|
|
if (reg_equiv_address[regno]
|
if (reg_equiv_address[regno]
|
|| ! rtx_equal_p (tem, reg_equiv_mem[regno]))
|
|| ! rtx_equal_p (tem, reg_equiv_mem[regno]))
|
{
|
{
|
rtx orig = tem;
|
rtx orig = tem;
|
|
|
/* First reload the memory location's address.
|
/* First reload the memory location's address.
|
We can't use ADDR_TYPE (type) here, because we need to
|
We can't use ADDR_TYPE (type) here, because we need to
|
write back the value after reading it, hence we actually
|
write back the value after reading it, hence we actually
|
need two registers. */
|
need two registers. */
|
find_reloads_address (GET_MODE (tem), &tem, XEXP (tem, 0),
|
find_reloads_address (GET_MODE (tem), &tem, XEXP (tem, 0),
|
&XEXP (tem, 0), opnum,
|
&XEXP (tem, 0), opnum,
|
RELOAD_OTHER,
|
RELOAD_OTHER,
|
ind_levels, insn);
|
ind_levels, insn);
|
|
|
if (tem != orig)
|
if (tem != orig)
|
push_reg_equiv_alt_mem (regno, tem);
|
push_reg_equiv_alt_mem (regno, tem);
|
|
|
/* Then reload the memory location into a base
|
/* Then reload the memory location into a base
|
register. */
|
register. */
|
reloadnum = push_reload (tem, tem, &XEXP (x, 0),
|
reloadnum = push_reload (tem, tem, &XEXP (x, 0),
|
&XEXP (op1, 0),
|
&XEXP (op1, 0),
|
base_reg_class (mode, code,
|
base_reg_class (mode, code,
|
index_code),
|
index_code),
|
GET_MODE (x), GET_MODE (x), 0,
|
GET_MODE (x), GET_MODE (x), 0,
|
0, opnum, RELOAD_OTHER);
|
0, opnum, RELOAD_OTHER);
|
|
|
update_auto_inc_notes (this_insn, regno, reloadnum);
|
update_auto_inc_notes (this_insn, regno, reloadnum);
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
|
|
if (reg_renumber[regno] >= 0)
|
if (reg_renumber[regno] >= 0)
|
regno = reg_renumber[regno];
|
regno = reg_renumber[regno];
|
|
|
/* We require a base register here... */
|
/* We require a base register here... */
|
if (!regno_ok_for_base_p (regno, GET_MODE (x), code, index_code))
|
if (!regno_ok_for_base_p (regno, GET_MODE (x), code, index_code))
|
{
|
{
|
reloadnum = push_reload (XEXP (op1, 0), XEXP (x, 0),
|
reloadnum = push_reload (XEXP (op1, 0), XEXP (x, 0),
|
&XEXP (op1, 0), &XEXP (x, 0),
|
&XEXP (op1, 0), &XEXP (x, 0),
|
base_reg_class (mode, code, index_code),
|
base_reg_class (mode, code, index_code),
|
GET_MODE (x), GET_MODE (x), 0, 0,
|
GET_MODE (x), GET_MODE (x), 0, 0,
|
opnum, RELOAD_OTHER);
|
opnum, RELOAD_OTHER);
|
|
|
update_auto_inc_notes (this_insn, regno, reloadnum);
|
update_auto_inc_notes (this_insn, regno, reloadnum);
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
return 0;
|
return 0;
|
|
|
case POST_INC:
|
case POST_INC:
|
case POST_DEC:
|
case POST_DEC:
|
case PRE_INC:
|
case PRE_INC:
|
case PRE_DEC:
|
case PRE_DEC:
|
if (REG_P (XEXP (x, 0)))
|
if (REG_P (XEXP (x, 0)))
|
{
|
{
|
int regno = REGNO (XEXP (x, 0));
|
int regno = REGNO (XEXP (x, 0));
|
int value = 0;
|
int value = 0;
|
rtx x_orig = x;
|
rtx x_orig = x;
|
|
|
/* A register that is incremented cannot be constant! */
|
/* A register that is incremented cannot be constant! */
|
gcc_assert (regno < FIRST_PSEUDO_REGISTER
|
gcc_assert (regno < FIRST_PSEUDO_REGISTER
|
|| reg_equiv_constant[regno] == 0);
|
|| reg_equiv_constant[regno] == 0);
|
|
|
/* Handle a register that is equivalent to a memory location
|
/* Handle a register that is equivalent to a memory location
|
which cannot be addressed directly. */
|
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))
|
&& (reg_equiv_address[regno] != 0 || num_not_at_initial_offset))
|
{
|
{
|
rtx tem = make_memloc (XEXP (x, 0), regno);
|
rtx tem = make_memloc (XEXP (x, 0), regno);
|
if (reg_equiv_address[regno]
|
if (reg_equiv_address[regno]
|
|| ! rtx_equal_p (tem, reg_equiv_mem[regno]))
|
|| ! rtx_equal_p (tem, reg_equiv_mem[regno]))
|
{
|
{
|
rtx orig = tem;
|
rtx orig = tem;
|
|
|
/* First reload the memory location's address.
|
/* First reload the memory location's address.
|
We can't use ADDR_TYPE (type) here, because we need to
|
We can't use ADDR_TYPE (type) here, because we need to
|
write back the value after reading it, hence we actually
|
write back the value after reading it, hence we actually
|
need two registers. */
|
need two registers. */
|
find_reloads_address (GET_MODE (tem), &tem, XEXP (tem, 0),
|
find_reloads_address (GET_MODE (tem), &tem, XEXP (tem, 0),
|
&XEXP (tem, 0), opnum, type,
|
&XEXP (tem, 0), opnum, type,
|
ind_levels, insn);
|
ind_levels, insn);
|
if (tem != orig)
|
if (tem != orig)
|
push_reg_equiv_alt_mem (regno, tem);
|
push_reg_equiv_alt_mem (regno, tem);
|
/* Put this inside a new increment-expression. */
|
/* Put this inside a new increment-expression. */
|
x = gen_rtx_fmt_e (GET_CODE (x), GET_MODE (x), tem);
|
x = gen_rtx_fmt_e (GET_CODE (x), GET_MODE (x), tem);
|
/* Proceed to reload that, as if it contained a register. */
|
/* Proceed to reload that, as if it contained a register. */
|
}
|
}
|
}
|
}
|
|
|
/* If we have a hard register that is ok as an index,
|
/* If we have a hard register that is ok as an index,
|
don't make a reload. If an autoincrement of a nice register
|
don't make a reload. If an autoincrement of a nice register
|
isn't "valid", it must be that no autoincrement is "valid".
|
isn't "valid", it must be that no autoincrement is "valid".
|
If that is true and something made an autoincrement anyway,
|
If that is true and something made an autoincrement anyway,
|
this must be a special context where one is allowed.
|
this must be a special context where one is allowed.
|
(For example, a "push" instruction.)
|
(For example, a "push" instruction.)
|
We can't improve this address, so leave it alone. */
|
We can't improve this address, so leave it alone. */
|
|
|
/* Otherwise, reload the autoincrement into a suitable hard reg
|
/* Otherwise, reload the autoincrement into a suitable hard reg
|
and record how much to increment by. */
|
and record how much to increment by. */
|
|
|
if (reg_renumber[regno] >= 0)
|
if (reg_renumber[regno] >= 0)
|
regno = reg_renumber[regno];
|
regno = reg_renumber[regno];
|
if (regno >= FIRST_PSEUDO_REGISTER
|
if (regno >= FIRST_PSEUDO_REGISTER
|
|| !REG_OK_FOR_CONTEXT (context, regno, mode, outer_code,
|
|| !REG_OK_FOR_CONTEXT (context, regno, mode, outer_code,
|
index_code))
|
index_code))
|
{
|
{
|
int reloadnum;
|
int reloadnum;
|
|
|
/* If we can output the register afterwards, do so, this
|
/* If we can output the register afterwards, do so, this
|
saves the extra update.
|
saves the extra update.
|
We can do so if we have an INSN - i.e. no JUMP_INSN nor
|
We can do so if we have an INSN - i.e. no JUMP_INSN nor
|
CALL_INSN - and it does not set CC0.
|
CALL_INSN - and it does not set CC0.
|
But don't do this if we cannot directly address the
|
But don't do this if we cannot directly address the
|
memory location, since this will make it harder to
|
memory location, since this will make it harder to
|
reuse address reloads, and increases register pressure.
|
reuse address reloads, and increases register pressure.
|
Also don't do this if we can probably update x directly. */
|
Also don't do this if we can probably update x directly. */
|
rtx equiv = (MEM_P (XEXP (x, 0))
|
rtx equiv = (MEM_P (XEXP (x, 0))
|
? XEXP (x, 0)
|
? XEXP (x, 0)
|
: reg_equiv_mem[regno]);
|
: reg_equiv_mem[regno]);
|
int icode = (int) add_optab->handlers[(int) Pmode].insn_code;
|
int icode = (int) add_optab->handlers[(int) Pmode].insn_code;
|
if (insn && NONJUMP_INSN_P (insn) && equiv
|
if (insn && NONJUMP_INSN_P (insn) && equiv
|
&& memory_operand (equiv, GET_MODE (equiv))
|
&& memory_operand (equiv, GET_MODE (equiv))
|
#ifdef HAVE_cc0
|
#ifdef HAVE_cc0
|
&& ! sets_cc0_p (PATTERN (insn))
|
&& ! sets_cc0_p (PATTERN (insn))
|
#endif
|
#endif
|
&& ! (icode != CODE_FOR_nothing
|
&& ! (icode != CODE_FOR_nothing
|
&& ((*insn_data[icode].operand[0].predicate)
|
&& ((*insn_data[icode].operand[0].predicate)
|
(equiv, Pmode))
|
(equiv, Pmode))
|
&& ((*insn_data[icode].operand[1].predicate)
|
&& ((*insn_data[icode].operand[1].predicate)
|
(equiv, Pmode))))
|
(equiv, Pmode))))
|
{
|
{
|
/* We use the original pseudo for loc, so that
|
/* We use the original pseudo for loc, so that
|
emit_reload_insns() knows which pseudo this
|
emit_reload_insns() knows which pseudo this
|
reload refers to and updates the pseudo rtx, not
|
reload refers to and updates the pseudo rtx, not
|
its equivalent memory location, as well as the
|
its equivalent memory location, as well as the
|
corresponding entry in reg_last_reload_reg. */
|
corresponding entry in reg_last_reload_reg. */
|
loc = &XEXP (x_orig, 0);
|
loc = &XEXP (x_orig, 0);
|
x = XEXP (x, 0);
|
x = XEXP (x, 0);
|
reloadnum
|
reloadnum
|
= push_reload (x, x, loc, loc,
|
= push_reload (x, x, loc, loc,
|
context_reg_class,
|
context_reg_class,
|
GET_MODE (x), GET_MODE (x), 0, 0,
|
GET_MODE (x), GET_MODE (x), 0, 0,
|
opnum, RELOAD_OTHER);
|
opnum, RELOAD_OTHER);
|
}
|
}
|
else
|
else
|
{
|
{
|
reloadnum
|
reloadnum
|
= push_reload (x, NULL_RTX, loc, (rtx*) 0,
|
= push_reload (x, NULL_RTX, loc, (rtx*) 0,
|
context_reg_class,
|
context_reg_class,
|
GET_MODE (x), GET_MODE (x), 0, 0,
|
GET_MODE (x), GET_MODE (x), 0, 0,
|
opnum, type);
|
opnum, type);
|
rld[reloadnum].inc
|
rld[reloadnum].inc
|
= find_inc_amount (PATTERN (this_insn), XEXP (x_orig, 0));
|
= find_inc_amount (PATTERN (this_insn), XEXP (x_orig, 0));
|
|
|
value = 1;
|
value = 1;
|
}
|
}
|
|
|
update_auto_inc_notes (this_insn, REGNO (XEXP (x_orig, 0)),
|
update_auto_inc_notes (this_insn, REGNO (XEXP (x_orig, 0)),
|
reloadnum);
|
reloadnum);
|
}
|
}
|
return value;
|
return value;
|
}
|
}
|
|
|
else if (MEM_P (XEXP (x, 0)))
|
else if (MEM_P (XEXP (x, 0)))
|
{
|
{
|
/* This is probably the result of a substitution, by eliminate_regs,
|
/* This is probably the result of a substitution, by eliminate_regs,
|
of an equivalent address for a pseudo that was not allocated to a
|
of an equivalent address for a pseudo that was not allocated to a
|
hard register. Verify that the specified address is valid and
|
hard register. Verify that the specified address is valid and
|
reload it into a register. */
|
reload it into a register. */
|
/* Variable `tem' might or might not be used in FIND_REG_INC_NOTE. */
|
/* Variable `tem' might or might not be used in FIND_REG_INC_NOTE. */
|
rtx tem ATTRIBUTE_UNUSED = XEXP (x, 0);
|
rtx tem ATTRIBUTE_UNUSED = XEXP (x, 0);
|
rtx link;
|
rtx link;
|
int reloadnum;
|
int reloadnum;
|
|
|
/* Since we know we are going to reload this item, don't decrement
|
/* Since we know we are going to reload this item, don't decrement
|
for the indirection level.
|
for the indirection level.
|
|
|
Note that this is actually conservative: it would be slightly
|
Note that this is actually conservative: it would be slightly
|
more efficient to use the value of SPILL_INDIRECT_LEVELS from
|
more efficient to use the value of SPILL_INDIRECT_LEVELS from
|
reload1.c here. */
|
reload1.c here. */
|
/* We can't use ADDR_TYPE (type) here, because we need to
|
/* We can't use ADDR_TYPE (type) here, because we need to
|
write back the value after reading it, hence we actually
|
write back the value after reading it, hence we actually
|
need two registers. */
|
need two registers. */
|
find_reloads_address (GET_MODE (x), &XEXP (x, 0),
|
find_reloads_address (GET_MODE (x), &XEXP (x, 0),
|
XEXP (XEXP (x, 0), 0), &XEXP (XEXP (x, 0), 0),
|
XEXP (XEXP (x, 0), 0), &XEXP (XEXP (x, 0), 0),
|
opnum, type, ind_levels, insn);
|
opnum, type, ind_levels, insn);
|
|
|
reloadnum = push_reload (x, NULL_RTX, loc, (rtx*) 0,
|
reloadnum = push_reload (x, NULL_RTX, loc, (rtx*) 0,
|
context_reg_class,
|
context_reg_class,
|
GET_MODE (x), VOIDmode, 0, 0, opnum, type);
|
GET_MODE (x), VOIDmode, 0, 0, opnum, type);
|
rld[reloadnum].inc
|
rld[reloadnum].inc
|
= find_inc_amount (PATTERN (this_insn), XEXP (x, 0));
|
= find_inc_amount (PATTERN (this_insn), XEXP (x, 0));
|
|
|
link = FIND_REG_INC_NOTE (this_insn, tem);
|
link = FIND_REG_INC_NOTE (this_insn, tem);
|
if (link != 0)
|
if (link != 0)
|
push_replacement (&XEXP (link, 0), reloadnum, VOIDmode);
|
push_replacement (&XEXP (link, 0), reloadnum, VOIDmode);
|
|
|
return 1;
|
return 1;
|
}
|
}
|
return 0;
|
return 0;
|
|
|
case TRUNCATE:
|
case TRUNCATE:
|
case SIGN_EXTEND:
|
case SIGN_EXTEND:
|
case ZERO_EXTEND:
|
case ZERO_EXTEND:
|
/* Look for parts to reload in the inner expression and reload them
|
/* Look for parts to reload in the inner expression and reload them
|
too, in addition to this operation. Reloading all inner parts in
|
too, in addition to this operation. Reloading all inner parts in
|
addition to this one shouldn't be necessary, but at this point,
|
addition to this one shouldn't be necessary, but at this point,
|
we don't know if we can possibly omit any part that *can* be
|
we don't know if we can possibly omit any part that *can* be
|
reloaded. Targets that are better off reloading just either part
|
reloaded. Targets that are better off reloading just either part
|
(or perhaps even a different part of an outer expression), should
|
(or perhaps even a different part of an outer expression), should
|
define LEGITIMIZE_RELOAD_ADDRESS. */
|
define LEGITIMIZE_RELOAD_ADDRESS. */
|
find_reloads_address_1 (GET_MODE (XEXP (x, 0)), XEXP (x, 0),
|
find_reloads_address_1 (GET_MODE (XEXP (x, 0)), XEXP (x, 0),
|
context, code, SCRATCH, &XEXP (x, 0), opnum,
|
context, code, SCRATCH, &XEXP (x, 0), opnum,
|
type, ind_levels, insn);
|
type, ind_levels, insn);
|
push_reload (x, NULL_RTX, loc, (rtx*) 0,
|
push_reload (x, NULL_RTX, loc, (rtx*) 0,
|
context_reg_class,
|
context_reg_class,
|
GET_MODE (x), VOIDmode, 0, 0, opnum, type);
|
GET_MODE (x), VOIDmode, 0, 0, opnum, type);
|
return 1;
|
return 1;
|
|
|
case MEM:
|
case MEM:
|
/* This is probably the result of a substitution, by eliminate_regs, of
|
/* This is probably the result of a substitution, by eliminate_regs, of
|
an equivalent address for a pseudo that was not allocated to a hard
|
an equivalent address for a pseudo that was not allocated to a hard
|
register. Verify that the specified address is valid and reload it
|
register. Verify that the specified address is valid and reload it
|
into a register.
|
into a register.
|
|
|
Since we know we are going to reload this item, don't decrement for
|
Since we know we are going to reload this item, don't decrement for
|
the indirection level.
|
the indirection level.
|
|
|
Note that this is actually conservative: it would be slightly more
|
Note that this is actually conservative: it would be slightly more
|
efficient to use the value of SPILL_INDIRECT_LEVELS from
|
efficient to use the value of SPILL_INDIRECT_LEVELS from
|
reload1.c here. */
|
reload1.c here. */
|
|
|
find_reloads_address (GET_MODE (x), loc, XEXP (x, 0), &XEXP (x, 0),
|
find_reloads_address (GET_MODE (x), loc, XEXP (x, 0), &XEXP (x, 0),
|
opnum, ADDR_TYPE (type), ind_levels, insn);
|
opnum, ADDR_TYPE (type), ind_levels, insn);
|
push_reload (*loc, NULL_RTX, loc, (rtx*) 0,
|
push_reload (*loc, NULL_RTX, loc, (rtx*) 0,
|
context_reg_class,
|
context_reg_class,
|
GET_MODE (x), VOIDmode, 0, 0, opnum, type);
|
GET_MODE (x), VOIDmode, 0, 0, opnum, type);
|
return 1;
|
return 1;
|
|
|
case REG:
|
case REG:
|
{
|
{
|
int regno = REGNO (x);
|
int regno = REGNO (x);
|
|
|
if (reg_equiv_constant[regno] != 0)
|
if (reg_equiv_constant[regno] != 0)
|
{
|
{
|
find_reloads_address_part (reg_equiv_constant[regno], loc,
|
find_reloads_address_part (reg_equiv_constant[regno], loc,
|
context_reg_class,
|
context_reg_class,
|
GET_MODE (x), opnum, type, ind_levels);
|
GET_MODE (x), opnum, type, ind_levels);
|
return 1;
|
return 1;
|
}
|
}
|
|
|
#if 0 /* This might screw code in reload1.c to delete prior output-reload
|
#if 0 /* This might screw code in reload1.c to delete prior output-reload
|
that feeds this insn. */
|
that feeds this insn. */
|
if (reg_equiv_mem[regno] != 0)
|
if (reg_equiv_mem[regno] != 0)
|
{
|
{
|
push_reload (reg_equiv_mem[regno], NULL_RTX, loc, (rtx*) 0,
|
push_reload (reg_equiv_mem[regno], NULL_RTX, loc, (rtx*) 0,
|
context_reg_class,
|
context_reg_class,
|
GET_MODE (x), VOIDmode, 0, 0, opnum, type);
|
GET_MODE (x), VOIDmode, 0, 0, opnum, type);
|
return 1;
|
return 1;
|
}
|
}
|
#endif
|
#endif
|
|
|
if (reg_equiv_memory_loc[regno]
|
if (reg_equiv_memory_loc[regno]
|
&& (reg_equiv_address[regno] != 0 || num_not_at_initial_offset))
|
&& (reg_equiv_address[regno] != 0 || num_not_at_initial_offset))
|
{
|
{
|
rtx tem = make_memloc (x, regno);
|
rtx tem = make_memloc (x, regno);
|
if (reg_equiv_address[regno] != 0
|
if (reg_equiv_address[regno] != 0
|
|| ! rtx_equal_p (tem, reg_equiv_mem[regno]))
|
|| ! rtx_equal_p (tem, reg_equiv_mem[regno]))
|
{
|
{
|
x = tem;
|
x = tem;
|
find_reloads_address (GET_MODE (x), &x, XEXP (x, 0),
|
find_reloads_address (GET_MODE (x), &x, XEXP (x, 0),
|
&XEXP (x, 0), opnum, ADDR_TYPE (type),
|
&XEXP (x, 0), opnum, ADDR_TYPE (type),
|
ind_levels, insn);
|
ind_levels, insn);
|
if (x != tem)
|
if (x != tem)
|
push_reg_equiv_alt_mem (regno, x);
|
push_reg_equiv_alt_mem (regno, x);
|
}
|
}
|
}
|
}
|
|
|
if (reg_renumber[regno] >= 0)
|
if (reg_renumber[regno] >= 0)
|
regno = reg_renumber[regno];
|
regno = reg_renumber[regno];
|
|
|
if (regno >= FIRST_PSEUDO_REGISTER
|
if (regno >= FIRST_PSEUDO_REGISTER
|
|| !REG_OK_FOR_CONTEXT (context, regno, mode, outer_code,
|
|| !REG_OK_FOR_CONTEXT (context, regno, mode, outer_code,
|
index_code))
|
index_code))
|
{
|
{
|
push_reload (x, NULL_RTX, loc, (rtx*) 0,
|
push_reload (x, NULL_RTX, loc, (rtx*) 0,
|
context_reg_class,
|
context_reg_class,
|
GET_MODE (x), VOIDmode, 0, 0, opnum, type);
|
GET_MODE (x), VOIDmode, 0, 0, opnum, type);
|
return 1;
|
return 1;
|
}
|
}
|
|
|
/* If a register appearing in an address is the subject of a CLOBBER
|
/* If a register appearing in an address is the subject of a CLOBBER
|
in this insn, reload it into some other register to be safe.
|
in this insn, reload it into some other register to be safe.
|
The CLOBBER is supposed to make the register unavailable
|
The CLOBBER is supposed to make the register unavailable
|
from before this insn to after it. */
|
from before this insn to after it. */
|
if (regno_clobbered_p (regno, this_insn, GET_MODE (x), 0))
|
if (regno_clobbered_p (regno, this_insn, GET_MODE (x), 0))
|
{
|
{
|
push_reload (x, NULL_RTX, loc, (rtx*) 0,
|
push_reload (x, NULL_RTX, loc, (rtx*) 0,
|
context_reg_class,
|
context_reg_class,
|
GET_MODE (x), VOIDmode, 0, 0, opnum, type);
|
GET_MODE (x), VOIDmode, 0, 0, opnum, type);
|
return 1;
|
return 1;
|
}
|
}
|
}
|
}
|
return 0;
|
return 0;
|
|
|
case SUBREG:
|
case SUBREG:
|
if (REG_P (SUBREG_REG (x)))
|
if (REG_P (SUBREG_REG (x)))
|
{
|
{
|
/* If this is a SUBREG of a hard register and the resulting register
|
/* If this is a SUBREG of a hard register and the resulting register
|
is of the wrong class, reload the whole SUBREG. This avoids
|
is of the wrong class, reload the whole SUBREG. This avoids
|
needless copies if SUBREG_REG is multi-word. */
|
needless copies if SUBREG_REG is multi-word. */
|
if (REGNO (SUBREG_REG (x)) < FIRST_PSEUDO_REGISTER)
|
if (REGNO (SUBREG_REG (x)) < FIRST_PSEUDO_REGISTER)
|
{
|
{
|
int regno ATTRIBUTE_UNUSED = subreg_regno (x);
|
int regno ATTRIBUTE_UNUSED = subreg_regno (x);
|
|
|
if (!REG_OK_FOR_CONTEXT (context, regno, mode, outer_code,
|
if (!REG_OK_FOR_CONTEXT (context, regno, mode, outer_code,
|
index_code))
|
index_code))
|
{
|
{
|
push_reload (x, NULL_RTX, loc, (rtx*) 0,
|
push_reload (x, NULL_RTX, loc, (rtx*) 0,
|
context_reg_class,
|
context_reg_class,
|
GET_MODE (x), VOIDmode, 0, 0, opnum, type);
|
GET_MODE (x), VOIDmode, 0, 0, opnum, type);
|
return 1;
|
return 1;
|
}
|
}
|
}
|
}
|
/* If this is a SUBREG of a pseudo-register, and the pseudo-register
|
/* If this is a SUBREG of a pseudo-register, and the pseudo-register
|
is larger than the class size, then reload the whole SUBREG. */
|
is larger than the class size, then reload the whole SUBREG. */
|
else
|
else
|
{
|
{
|
enum reg_class class = context_reg_class;
|
enum reg_class class = context_reg_class;
|
if ((unsigned) CLASS_MAX_NREGS (class, GET_MODE (SUBREG_REG (x)))
|
if ((unsigned) CLASS_MAX_NREGS (class, GET_MODE (SUBREG_REG (x)))
|
> reg_class_size[class])
|
> reg_class_size[class])
|
{
|
{
|
x = find_reloads_subreg_address (x, 0, opnum,
|
x = find_reloads_subreg_address (x, 0, opnum,
|
ADDR_TYPE (type),
|
ADDR_TYPE (type),
|
ind_levels, insn);
|
ind_levels, insn);
|
push_reload (x, NULL_RTX, loc, (rtx*) 0, class,
|
push_reload (x, NULL_RTX, loc, (rtx*) 0, class,
|
GET_MODE (x), VOIDmode, 0, 0, opnum, type);
|
GET_MODE (x), VOIDmode, 0, 0, opnum, type);
|
return 1;
|
return 1;
|
}
|
}
|
}
|
}
|
}
|
}
|
break;
|
break;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
{
|
{
|
const char *fmt = GET_RTX_FORMAT (code);
|
const char *fmt = GET_RTX_FORMAT (code);
|
int i;
|
int i;
|
|
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
{
|
{
|
if (fmt[i] == 'e')
|
if (fmt[i] == 'e')
|
/* Pass SCRATCH for INDEX_CODE, since CODE can never be a PLUS once
|
/* Pass SCRATCH for INDEX_CODE, since CODE can never be a PLUS once
|
we get here. */
|
we get here. */
|
find_reloads_address_1 (mode, XEXP (x, i), context, code, SCRATCH,
|
find_reloads_address_1 (mode, XEXP (x, i), context, code, SCRATCH,
|
&XEXP (x, i), opnum, type, ind_levels, insn);
|
&XEXP (x, i), opnum, type, ind_levels, insn);
|
}
|
}
|
}
|
}
|
|
|
#undef REG_OK_FOR_CONTEXT
|
#undef REG_OK_FOR_CONTEXT
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* X, which is found at *LOC, is a part of an address that needs to be
|
/* X, which is found at *LOC, is a part of an address that needs to be
|
reloaded into a register of class CLASS. If X is a constant, or if
|
reloaded into a register of class CLASS. If X is a constant, or if
|
X is a PLUS that contains a constant, check that the constant is a
|
X is a PLUS that contains a constant, check that the constant is a
|
legitimate operand and that we are supposed to be able to load
|
legitimate operand and that we are supposed to be able to load
|
it into the register.
|
it into the register.
|
|
|
If not, force the constant into memory and reload the MEM instead.
|
If not, force the constant into memory and reload the MEM instead.
|
|
|
MODE is the mode to use, in case X is an integer constant.
|
MODE is the mode to use, in case X is an integer constant.
|
|
|
OPNUM and TYPE describe the purpose of any reloads made.
|
OPNUM and TYPE describe the purpose of any reloads made.
|
|
|
IND_LEVELS says how many levels of indirect addressing this machine
|
IND_LEVELS says how many levels of indirect addressing this machine
|
supports. */
|
supports. */
|
|
|
static void
|
static void
|
find_reloads_address_part (rtx x, rtx *loc, enum reg_class class,
|
find_reloads_address_part (rtx x, rtx *loc, enum reg_class class,
|
enum machine_mode mode, int opnum,
|
enum machine_mode mode, int opnum,
|
enum reload_type type, int ind_levels)
|
enum reload_type type, int ind_levels)
|
{
|
{
|
if (CONSTANT_P (x)
|
if (CONSTANT_P (x)
|
&& (! LEGITIMATE_CONSTANT_P (x)
|
&& (! LEGITIMATE_CONSTANT_P (x)
|
|| PREFERRED_RELOAD_CLASS (x, class) == NO_REGS))
|
|| PREFERRED_RELOAD_CLASS (x, class) == NO_REGS))
|
{
|
{
|
rtx tem;
|
rtx tem;
|
|
|
tem = x = force_const_mem (mode, x);
|
tem = x = force_const_mem (mode, x);
|
find_reloads_address (mode, &tem, XEXP (tem, 0), &XEXP (tem, 0),
|
find_reloads_address (mode, &tem, XEXP (tem, 0), &XEXP (tem, 0),
|
opnum, type, ind_levels, 0);
|
opnum, type, ind_levels, 0);
|
}
|
}
|
|
|
else if (GET_CODE (x) == PLUS
|
else if (GET_CODE (x) == PLUS
|
&& CONSTANT_P (XEXP (x, 1))
|
&& CONSTANT_P (XEXP (x, 1))
|
&& (! LEGITIMATE_CONSTANT_P (XEXP (x, 1))
|
&& (! LEGITIMATE_CONSTANT_P (XEXP (x, 1))
|
|| PREFERRED_RELOAD_CLASS (XEXP (x, 1), class) == NO_REGS))
|
|| PREFERRED_RELOAD_CLASS (XEXP (x, 1), class) == NO_REGS))
|
{
|
{
|
rtx tem;
|
rtx tem;
|
|
|
tem = force_const_mem (GET_MODE (x), XEXP (x, 1));
|
tem = force_const_mem (GET_MODE (x), XEXP (x, 1));
|
x = gen_rtx_PLUS (GET_MODE (x), XEXP (x, 0), tem);
|
x = gen_rtx_PLUS (GET_MODE (x), XEXP (x, 0), tem);
|
find_reloads_address (mode, &tem, XEXP (tem, 0), &XEXP (tem, 0),
|
find_reloads_address (mode, &tem, XEXP (tem, 0), &XEXP (tem, 0),
|
opnum, type, ind_levels, 0);
|
opnum, type, ind_levels, 0);
|
}
|
}
|
|
|
push_reload (x, NULL_RTX, loc, (rtx*) 0, class,
|
push_reload (x, NULL_RTX, loc, (rtx*) 0, class,
|
mode, VOIDmode, 0, 0, opnum, type);
|
mode, VOIDmode, 0, 0, opnum, type);
|
}
|
}
|
|
|
/* X, a subreg of a pseudo, is a part of an address that needs to be
|
/* X, a subreg of a pseudo, is a part of an address that needs to be
|
reloaded.
|
reloaded.
|
|
|
If the pseudo is equivalent to a memory location that cannot be directly
|
If the pseudo is equivalent to a memory location that cannot be directly
|
addressed, make the necessary address reloads.
|
addressed, make the necessary address reloads.
|
|
|
If address reloads have been necessary, or if the address is changed
|
If address reloads have been necessary, or if the address is changed
|
by register elimination, return the rtx of the memory location;
|
by register elimination, return the rtx of the memory location;
|
otherwise, return X.
|
otherwise, return X.
|
|
|
If FORCE_REPLACE is nonzero, unconditionally replace the subreg with the
|
If FORCE_REPLACE is nonzero, unconditionally replace the subreg with the
|
memory location.
|
memory location.
|
|
|
OPNUM and TYPE identify the purpose of the reload.
|
OPNUM and TYPE identify the purpose of the reload.
|
|
|
IND_LEVELS says how many levels of indirect addressing are
|
IND_LEVELS says how many levels of indirect addressing are
|
supported at this point in the address.
|
supported at this point in the address.
|
|
|
INSN, if nonzero, is the insn in which we do the reload. It is used
|
INSN, if nonzero, is the insn in which we do the reload. It is used
|
to determine where to put USEs for pseudos that we have to replace with
|
to determine where to put USEs for pseudos that we have to replace with
|
stack slots. */
|
stack slots. */
|
|
|
static rtx
|
static rtx
|
find_reloads_subreg_address (rtx x, int force_replace, int opnum,
|
find_reloads_subreg_address (rtx x, int force_replace, int opnum,
|
enum reload_type type, int ind_levels, rtx insn)
|
enum reload_type type, int ind_levels, rtx insn)
|
{
|
{
|
int regno = REGNO (SUBREG_REG (x));
|
int regno = REGNO (SUBREG_REG (x));
|
|
|
if (reg_equiv_memory_loc[regno])
|
if (reg_equiv_memory_loc[regno])
|
{
|
{
|
/* If the address is not directly addressable, or if the address is not
|
/* If the address is not directly addressable, or if the address is not
|
offsettable, then it must be replaced. */
|
offsettable, then it must be replaced. */
|
if (! force_replace
|
if (! force_replace
|
&& (reg_equiv_address[regno]
|
&& (reg_equiv_address[regno]
|
|| ! offsettable_memref_p (reg_equiv_mem[regno])))
|
|| ! offsettable_memref_p (reg_equiv_mem[regno])))
|
force_replace = 1;
|
force_replace = 1;
|
|
|
if (force_replace || num_not_at_initial_offset)
|
if (force_replace || num_not_at_initial_offset)
|
{
|
{
|
rtx tem = make_memloc (SUBREG_REG (x), regno);
|
rtx tem = make_memloc (SUBREG_REG (x), regno);
|
|
|
/* If the address changes because of register elimination, then
|
/* If the address changes because of register elimination, then
|
it must be replaced. */
|
it must be replaced. */
|
if (force_replace
|
if (force_replace
|
|| ! rtx_equal_p (tem, reg_equiv_mem[regno]))
|
|| ! rtx_equal_p (tem, reg_equiv_mem[regno]))
|
{
|
{
|
unsigned outer_size = GET_MODE_SIZE (GET_MODE (x));
|
unsigned outer_size = GET_MODE_SIZE (GET_MODE (x));
|
unsigned inner_size = GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)));
|
unsigned inner_size = GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)));
|
int offset;
|
int offset;
|
rtx orig = tem;
|
rtx orig = tem;
|
enum machine_mode orig_mode = GET_MODE (orig);
|
enum machine_mode orig_mode = GET_MODE (orig);
|
int reloaded;
|
int reloaded;
|
|
|
/* For big-endian paradoxical subregs, SUBREG_BYTE does not
|
/* For big-endian paradoxical subregs, SUBREG_BYTE does not
|
hold the correct (negative) byte offset. */
|
hold the correct (negative) byte offset. */
|
if (BYTES_BIG_ENDIAN && outer_size > inner_size)
|
if (BYTES_BIG_ENDIAN && outer_size > inner_size)
|
offset = inner_size - outer_size;
|
offset = inner_size - outer_size;
|
else
|
else
|
offset = SUBREG_BYTE (x);
|
offset = SUBREG_BYTE (x);
|
|
|
XEXP (tem, 0) = plus_constant (XEXP (tem, 0), offset);
|
XEXP (tem, 0) = plus_constant (XEXP (tem, 0), offset);
|
PUT_MODE (tem, GET_MODE (x));
|
PUT_MODE (tem, GET_MODE (x));
|
|
|
/* If this was a paradoxical subreg that we replaced, the
|
/* If this was a paradoxical subreg that we replaced, the
|
resulting memory must be sufficiently aligned to allow
|
resulting memory must be sufficiently aligned to allow
|
us to widen the mode of the memory. */
|
us to widen the mode of the memory. */
|
if (outer_size > inner_size)
|
if (outer_size > inner_size)
|
{
|
{
|
rtx base;
|
rtx base;
|
|
|
base = XEXP (tem, 0);
|
base = XEXP (tem, 0);
|
if (GET_CODE (base) == PLUS)
|
if (GET_CODE (base) == PLUS)
|
{
|
{
|
if (GET_CODE (XEXP (base, 1)) == CONST_INT
|
if (GET_CODE (XEXP (base, 1)) == CONST_INT
|
&& INTVAL (XEXP (base, 1)) % outer_size != 0)
|
&& INTVAL (XEXP (base, 1)) % outer_size != 0)
|
return x;
|
return x;
|
base = XEXP (base, 0);
|
base = XEXP (base, 0);
|
}
|
}
|
if (!REG_P (base)
|
if (!REG_P (base)
|
|| (REGNO_POINTER_ALIGN (REGNO (base))
|
|| (REGNO_POINTER_ALIGN (REGNO (base))
|
< outer_size * BITS_PER_UNIT))
|
< outer_size * BITS_PER_UNIT))
|
return x;
|
return x;
|
}
|
}
|
|
|
reloaded = find_reloads_address (GET_MODE (tem), &tem,
|
reloaded = find_reloads_address (GET_MODE (tem), &tem,
|
XEXP (tem, 0), &XEXP (tem, 0),
|
XEXP (tem, 0), &XEXP (tem, 0),
|
opnum, type, ind_levels, insn);
|
opnum, type, ind_levels, insn);
|
/* ??? Do we need to handle nonzero offsets somehow? */
|
/* ??? Do we need to handle nonzero offsets somehow? */
|
if (!offset && tem != orig)
|
if (!offset && tem != orig)
|
push_reg_equiv_alt_mem (regno, tem);
|
push_reg_equiv_alt_mem (regno, tem);
|
|
|
/* For some processors an address may be valid in the
|
/* For some processors an address may be valid in the
|
original mode but not in a smaller mode. For
|
original mode but not in a smaller mode. For
|
example, ARM accepts a scaled index register in
|
example, ARM accepts a scaled index register in
|
SImode but not in HImode. find_reloads_address
|
SImode but not in HImode. find_reloads_address
|
assumes that we pass it a valid address, and doesn't
|
assumes that we pass it a valid address, and doesn't
|
force a reload. This will probably be fine if
|
force a reload. This will probably be fine if
|
find_reloads_address finds some reloads. But if it
|
find_reloads_address finds some reloads. But if it
|
doesn't find any, then we may have just converted a
|
doesn't find any, then we may have just converted a
|
valid address into an invalid one. Check for that
|
valid address into an invalid one. Check for that
|
here. */
|
here. */
|
if (reloaded != 1
|
if (reloaded != 1
|
&& strict_memory_address_p (orig_mode, XEXP (tem, 0))
|
&& strict_memory_address_p (orig_mode, XEXP (tem, 0))
|
&& !strict_memory_address_p (GET_MODE (tem),
|
&& !strict_memory_address_p (GET_MODE (tem),
|
XEXP (tem, 0)))
|
XEXP (tem, 0)))
|
push_reload (XEXP (tem, 0), NULL_RTX, &XEXP (tem, 0), (rtx*) 0,
|
push_reload (XEXP (tem, 0), NULL_RTX, &XEXP (tem, 0), (rtx*) 0,
|
base_reg_class (GET_MODE (tem), MEM, SCRATCH),
|
base_reg_class (GET_MODE (tem), MEM, SCRATCH),
|
GET_MODE (XEXP (tem, 0)), VOIDmode, 0, 0,
|
GET_MODE (XEXP (tem, 0)), VOIDmode, 0, 0,
|
opnum, type);
|
opnum, type);
|
|
|
/* If this is not a toplevel operand, find_reloads doesn't see
|
/* If this is not a toplevel operand, find_reloads doesn't see
|
this substitution. We have to emit a USE of the pseudo so
|
this substitution. We have to emit a USE of the pseudo so
|
that delete_output_reload can see it. */
|
that delete_output_reload can see it. */
|
if (replace_reloads && recog_data.operand[opnum] != x)
|
if (replace_reloads && recog_data.operand[opnum] != x)
|
/* We mark the USE with QImode so that we recognize it
|
/* We mark the USE with QImode so that we recognize it
|
as one that can be safely deleted at the end of
|
as one that can be safely deleted at the end of
|
reload. */
|
reload. */
|
PUT_MODE (emit_insn_before (gen_rtx_USE (VOIDmode,
|
PUT_MODE (emit_insn_before (gen_rtx_USE (VOIDmode,
|
SUBREG_REG (x)),
|
SUBREG_REG (x)),
|
insn), QImode);
|
insn), QImode);
|
x = tem;
|
x = tem;
|
}
|
}
|
}
|
}
|
}
|
}
|
return x;
|
return x;
|
}
|
}
|
|
|
/* Substitute into the current INSN the registers into which we have reloaded
|
/* Substitute into the current INSN the registers into which we have reloaded
|
the things that need reloading. The array `replacements'
|
the things that need reloading. The array `replacements'
|
contains the locations of all pointers that must be changed
|
contains the locations of all pointers that must be changed
|
and says what to replace them with.
|
and says what to replace them with.
|
|
|
Return the rtx that X translates into; usually X, but modified. */
|
Return the rtx that X translates into; usually X, but modified. */
|
|
|
void
|
void
|
subst_reloads (rtx insn)
|
subst_reloads (rtx insn)
|
{
|
{
|
int i;
|
int i;
|
|
|
for (i = 0; i < n_replacements; i++)
|
for (i = 0; i < n_replacements; i++)
|
{
|
{
|
struct replacement *r = &replacements[i];
|
struct replacement *r = &replacements[i];
|
rtx reloadreg = rld[r->what].reg_rtx;
|
rtx reloadreg = rld[r->what].reg_rtx;
|
if (reloadreg)
|
if (reloadreg)
|
{
|
{
|
#ifdef ENABLE_CHECKING
|
#ifdef ENABLE_CHECKING
|
/* Internal consistency test. Check that we don't modify
|
/* Internal consistency test. Check that we don't modify
|
anything in the equivalence arrays. Whenever something from
|
anything in the equivalence arrays. Whenever something from
|
those arrays needs to be reloaded, it must be unshared before
|
those arrays needs to be reloaded, it must be unshared before
|
being substituted into; the equivalence must not be modified.
|
being substituted into; the equivalence must not be modified.
|
Otherwise, if the equivalence is used after that, it will
|
Otherwise, if the equivalence is used after that, it will
|
have been modified, and the thing substituted (probably a
|
have been modified, and the thing substituted (probably a
|
register) is likely overwritten and not a usable equivalence. */
|
register) is likely overwritten and not a usable equivalence. */
|
int check_regno;
|
int check_regno;
|
|
|
for (check_regno = 0; check_regno < max_regno; check_regno++)
|
for (check_regno = 0; check_regno < max_regno; check_regno++)
|
{
|
{
|
#define CHECK_MODF(ARRAY) \
|
#define CHECK_MODF(ARRAY) \
|
gcc_assert (!ARRAY[check_regno] \
|
gcc_assert (!ARRAY[check_regno] \
|
|| !loc_mentioned_in_p (r->where, \
|
|| !loc_mentioned_in_p (r->where, \
|
ARRAY[check_regno]))
|
ARRAY[check_regno]))
|
|
|
CHECK_MODF (reg_equiv_constant);
|
CHECK_MODF (reg_equiv_constant);
|
CHECK_MODF (reg_equiv_memory_loc);
|
CHECK_MODF (reg_equiv_memory_loc);
|
CHECK_MODF (reg_equiv_address);
|
CHECK_MODF (reg_equiv_address);
|
CHECK_MODF (reg_equiv_mem);
|
CHECK_MODF (reg_equiv_mem);
|
#undef CHECK_MODF
|
#undef CHECK_MODF
|
}
|
}
|
#endif /* ENABLE_CHECKING */
|
#endif /* ENABLE_CHECKING */
|
|
|
/* If we're replacing a LABEL_REF with a register, add a
|
/* If we're replacing a LABEL_REF with a register, add a
|
REG_LABEL note to indicate to flow which label this
|
REG_LABEL note to indicate to flow which label this
|
register refers to. */
|
register refers to. */
|
if (GET_CODE (*r->where) == LABEL_REF
|
if (GET_CODE (*r->where) == LABEL_REF
|
&& JUMP_P (insn))
|
&& JUMP_P (insn))
|
{
|
{
|
REG_NOTES (insn) = gen_rtx_INSN_LIST (REG_LABEL,
|
REG_NOTES (insn) = gen_rtx_INSN_LIST (REG_LABEL,
|
XEXP (*r->where, 0),
|
XEXP (*r->where, 0),
|
REG_NOTES (insn));
|
REG_NOTES (insn));
|
JUMP_LABEL (insn) = XEXP (*r->where, 0);
|
JUMP_LABEL (insn) = XEXP (*r->where, 0);
|
}
|
}
|
|
|
/* Encapsulate RELOADREG so its machine mode matches what
|
/* Encapsulate RELOADREG so its machine mode matches what
|
used to be there. Note that gen_lowpart_common will
|
used to be there. Note that gen_lowpart_common will
|
do the wrong thing if RELOADREG is multi-word. RELOADREG
|
do the wrong thing if RELOADREG is multi-word. RELOADREG
|
will always be a REG here. */
|
will always be a REG here. */
|
if (GET_MODE (reloadreg) != r->mode && r->mode != VOIDmode)
|
if (GET_MODE (reloadreg) != r->mode && r->mode != VOIDmode)
|
reloadreg = reload_adjust_reg_for_mode (reloadreg, r->mode);
|
reloadreg = reload_adjust_reg_for_mode (reloadreg, r->mode);
|
|
|
/* If we are putting this into a SUBREG and RELOADREG is a
|
/* If we are putting this into a SUBREG and RELOADREG is a
|
SUBREG, we would be making nested SUBREGs, so we have to fix
|
SUBREG, we would be making nested SUBREGs, so we have to fix
|
this up. Note that r->where == &SUBREG_REG (*r->subreg_loc). */
|
this up. Note that r->where == &SUBREG_REG (*r->subreg_loc). */
|
|
|
if (r->subreg_loc != 0 && GET_CODE (reloadreg) == SUBREG)
|
if (r->subreg_loc != 0 && GET_CODE (reloadreg) == SUBREG)
|
{
|
{
|
if (GET_MODE (*r->subreg_loc)
|
if (GET_MODE (*r->subreg_loc)
|
== GET_MODE (SUBREG_REG (reloadreg)))
|
== GET_MODE (SUBREG_REG (reloadreg)))
|
*r->subreg_loc = SUBREG_REG (reloadreg);
|
*r->subreg_loc = SUBREG_REG (reloadreg);
|
else
|
else
|
{
|
{
|
int final_offset =
|
int final_offset =
|
SUBREG_BYTE (*r->subreg_loc) + SUBREG_BYTE (reloadreg);
|
SUBREG_BYTE (*r->subreg_loc) + SUBREG_BYTE (reloadreg);
|
|
|
/* When working with SUBREGs the rule is that the byte
|
/* When working with SUBREGs the rule is that the byte
|
offset must be a multiple of the SUBREG's mode. */
|
offset must be a multiple of the SUBREG's mode. */
|
final_offset = (final_offset /
|
final_offset = (final_offset /
|
GET_MODE_SIZE (GET_MODE (*r->subreg_loc)));
|
GET_MODE_SIZE (GET_MODE (*r->subreg_loc)));
|
final_offset = (final_offset *
|
final_offset = (final_offset *
|
GET_MODE_SIZE (GET_MODE (*r->subreg_loc)));
|
GET_MODE_SIZE (GET_MODE (*r->subreg_loc)));
|
|
|
*r->where = SUBREG_REG (reloadreg);
|
*r->where = SUBREG_REG (reloadreg);
|
SUBREG_BYTE (*r->subreg_loc) = final_offset;
|
SUBREG_BYTE (*r->subreg_loc) = final_offset;
|
}
|
}
|
}
|
}
|
else
|
else
|
*r->where = reloadreg;
|
*r->where = reloadreg;
|
}
|
}
|
/* If reload got no reg and isn't optional, something's wrong. */
|
/* If reload got no reg and isn't optional, something's wrong. */
|
else
|
else
|
gcc_assert (rld[r->what].optional);
|
gcc_assert (rld[r->what].optional);
|
}
|
}
|
}
|
}
|
|
|
/* Make a copy of any replacements being done into X and move those
|
/* Make a copy of any replacements being done into X and move those
|
copies to locations in Y, a copy of X. */
|
copies to locations in Y, a copy of X. */
|
|
|
void
|
void
|
copy_replacements (rtx x, rtx y)
|
copy_replacements (rtx x, rtx y)
|
{
|
{
|
/* We can't support X being a SUBREG because we might then need to know its
|
/* We can't support X being a SUBREG because we might then need to know its
|
location if something inside it was replaced. */
|
location if something inside it was replaced. */
|
gcc_assert (GET_CODE (x) != SUBREG);
|
gcc_assert (GET_CODE (x) != SUBREG);
|
|
|
copy_replacements_1 (&x, &y, n_replacements);
|
copy_replacements_1 (&x, &y, n_replacements);
|
}
|
}
|
|
|
static void
|
static void
|
copy_replacements_1 (rtx *px, rtx *py, int orig_replacements)
|
copy_replacements_1 (rtx *px, rtx *py, int orig_replacements)
|
{
|
{
|
int i, j;
|
int i, j;
|
rtx x, y;
|
rtx x, y;
|
struct replacement *r;
|
struct replacement *r;
|
enum rtx_code code;
|
enum rtx_code code;
|
const char *fmt;
|
const char *fmt;
|
|
|
for (j = 0; j < orig_replacements; j++)
|
for (j = 0; j < orig_replacements; j++)
|
{
|
{
|
if (replacements[j].subreg_loc == px)
|
if (replacements[j].subreg_loc == px)
|
{
|
{
|
r = &replacements[n_replacements++];
|
r = &replacements[n_replacements++];
|
r->where = replacements[j].where;
|
r->where = replacements[j].where;
|
r->subreg_loc = py;
|
r->subreg_loc = py;
|
r->what = replacements[j].what;
|
r->what = replacements[j].what;
|
r->mode = replacements[j].mode;
|
r->mode = replacements[j].mode;
|
}
|
}
|
else if (replacements[j].where == px)
|
else if (replacements[j].where == px)
|
{
|
{
|
r = &replacements[n_replacements++];
|
r = &replacements[n_replacements++];
|
r->where = py;
|
r->where = py;
|
r->subreg_loc = 0;
|
r->subreg_loc = 0;
|
r->what = replacements[j].what;
|
r->what = replacements[j].what;
|
r->mode = replacements[j].mode;
|
r->mode = replacements[j].mode;
|
}
|
}
|
}
|
}
|
|
|
x = *px;
|
x = *px;
|
y = *py;
|
y = *py;
|
code = GET_CODE (x);
|
code = GET_CODE (x);
|
fmt = GET_RTX_FORMAT (code);
|
fmt = GET_RTX_FORMAT (code);
|
|
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
{
|
{
|
if (fmt[i] == 'e')
|
if (fmt[i] == 'e')
|
copy_replacements_1 (&XEXP (x, i), &XEXP (y, i), orig_replacements);
|
copy_replacements_1 (&XEXP (x, i), &XEXP (y, i), orig_replacements);
|
else if (fmt[i] == 'E')
|
else if (fmt[i] == 'E')
|
for (j = XVECLEN (x, i); --j >= 0; )
|
for (j = XVECLEN (x, i); --j >= 0; )
|
copy_replacements_1 (&XVECEXP (x, i, j), &XVECEXP (y, i, j),
|
copy_replacements_1 (&XVECEXP (x, i, j), &XVECEXP (y, i, j),
|
orig_replacements);
|
orig_replacements);
|
}
|
}
|
}
|
}
|
|
|
/* Change any replacements being done to *X to be done to *Y. */
|
/* Change any replacements being done to *X to be done to *Y. */
|
|
|
void
|
void
|
move_replacements (rtx *x, rtx *y)
|
move_replacements (rtx *x, rtx *y)
|
{
|
{
|
int i;
|
int i;
|
|
|
for (i = 0; i < n_replacements; i++)
|
for (i = 0; i < n_replacements; i++)
|
if (replacements[i].subreg_loc == x)
|
if (replacements[i].subreg_loc == x)
|
replacements[i].subreg_loc = y;
|
replacements[i].subreg_loc = y;
|
else if (replacements[i].where == x)
|
else if (replacements[i].where == x)
|
{
|
{
|
replacements[i].where = y;
|
replacements[i].where = y;
|
replacements[i].subreg_loc = 0;
|
replacements[i].subreg_loc = 0;
|
}
|
}
|
}
|
}
|
|
|
/* If LOC was scheduled to be replaced by something, return the replacement.
|
/* If LOC was scheduled to be replaced by something, return the replacement.
|
Otherwise, return *LOC. */
|
Otherwise, return *LOC. */
|
|
|
rtx
|
rtx
|
find_replacement (rtx *loc)
|
find_replacement (rtx *loc)
|
{
|
{
|
struct replacement *r;
|
struct replacement *r;
|
|
|
for (r = &replacements[0]; r < &replacements[n_replacements]; r++)
|
for (r = &replacements[0]; r < &replacements[n_replacements]; r++)
|
{
|
{
|
rtx reloadreg = rld[r->what].reg_rtx;
|
rtx reloadreg = rld[r->what].reg_rtx;
|
|
|
if (reloadreg && r->where == loc)
|
if (reloadreg && r->where == loc)
|
{
|
{
|
if (r->mode != VOIDmode && GET_MODE (reloadreg) != r->mode)
|
if (r->mode != VOIDmode && GET_MODE (reloadreg) != r->mode)
|
reloadreg = gen_rtx_REG (r->mode, REGNO (reloadreg));
|
reloadreg = gen_rtx_REG (r->mode, REGNO (reloadreg));
|
|
|
return reloadreg;
|
return reloadreg;
|
}
|
}
|
else if (reloadreg && r->subreg_loc == loc)
|
else if (reloadreg && r->subreg_loc == loc)
|
{
|
{
|
/* RELOADREG must be either a REG or a SUBREG.
|
/* RELOADREG must be either a REG or a SUBREG.
|
|
|
??? Is it actually still ever a SUBREG? If so, why? */
|
??? Is it actually still ever a SUBREG? If so, why? */
|
|
|
if (REG_P (reloadreg))
|
if (REG_P (reloadreg))
|
return gen_rtx_REG (GET_MODE (*loc),
|
return gen_rtx_REG (GET_MODE (*loc),
|
(REGNO (reloadreg) +
|
(REGNO (reloadreg) +
|
subreg_regno_offset (REGNO (SUBREG_REG (*loc)),
|
subreg_regno_offset (REGNO (SUBREG_REG (*loc)),
|
GET_MODE (SUBREG_REG (*loc)),
|
GET_MODE (SUBREG_REG (*loc)),
|
SUBREG_BYTE (*loc),
|
SUBREG_BYTE (*loc),
|
GET_MODE (*loc))));
|
GET_MODE (*loc))));
|
else if (GET_MODE (reloadreg) == GET_MODE (*loc))
|
else if (GET_MODE (reloadreg) == GET_MODE (*loc))
|
return reloadreg;
|
return reloadreg;
|
else
|
else
|
{
|
{
|
int final_offset = SUBREG_BYTE (reloadreg) + SUBREG_BYTE (*loc);
|
int final_offset = SUBREG_BYTE (reloadreg) + SUBREG_BYTE (*loc);
|
|
|
/* When working with SUBREGs the rule is that the byte
|
/* When working with SUBREGs the rule is that the byte
|
offset must be a multiple of the SUBREG's mode. */
|
offset must be a multiple of the SUBREG's mode. */
|
final_offset = (final_offset / GET_MODE_SIZE (GET_MODE (*loc)));
|
final_offset = (final_offset / GET_MODE_SIZE (GET_MODE (*loc)));
|
final_offset = (final_offset * GET_MODE_SIZE (GET_MODE (*loc)));
|
final_offset = (final_offset * GET_MODE_SIZE (GET_MODE (*loc)));
|
return gen_rtx_SUBREG (GET_MODE (*loc), SUBREG_REG (reloadreg),
|
return gen_rtx_SUBREG (GET_MODE (*loc), SUBREG_REG (reloadreg),
|
final_offset);
|
final_offset);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* If *LOC is a PLUS, MINUS, or MULT, see if a replacement is scheduled for
|
/* If *LOC is a PLUS, MINUS, or MULT, see if a replacement is scheduled for
|
what's inside and make a new rtl if so. */
|
what's inside and make a new rtl if so. */
|
if (GET_CODE (*loc) == PLUS || GET_CODE (*loc) == MINUS
|
if (GET_CODE (*loc) == PLUS || GET_CODE (*loc) == MINUS
|
|| GET_CODE (*loc) == MULT)
|
|| GET_CODE (*loc) == MULT)
|
{
|
{
|
rtx x = find_replacement (&XEXP (*loc, 0));
|
rtx x = find_replacement (&XEXP (*loc, 0));
|
rtx y = find_replacement (&XEXP (*loc, 1));
|
rtx y = find_replacement (&XEXP (*loc, 1));
|
|
|
if (x != XEXP (*loc, 0) || y != XEXP (*loc, 1))
|
if (x != XEXP (*loc, 0) || y != XEXP (*loc, 1))
|
return gen_rtx_fmt_ee (GET_CODE (*loc), GET_MODE (*loc), x, y);
|
return gen_rtx_fmt_ee (GET_CODE (*loc), GET_MODE (*loc), x, y);
|
}
|
}
|
|
|
return *loc;
|
return *loc;
|
}
|
}
|
|
|
/* Return nonzero if register in range [REGNO, ENDREGNO)
|
/* Return nonzero if register in range [REGNO, ENDREGNO)
|
appears either explicitly or implicitly in X
|
appears either explicitly or implicitly in X
|
other than being stored into (except for earlyclobber operands).
|
other than being stored into (except for earlyclobber operands).
|
|
|
References contained within the substructure at LOC do not count.
|
References contained within the substructure at LOC do not count.
|
LOC may be zero, meaning don't ignore anything.
|
LOC may be zero, meaning don't ignore anything.
|
|
|
This is similar to refers_to_regno_p in rtlanal.c except that we
|
This is similar to refers_to_regno_p in rtlanal.c except that we
|
look at equivalences for pseudos that didn't get hard registers. */
|
look at equivalences for pseudos that didn't get hard registers. */
|
|
|
static int
|
static int
|
refers_to_regno_for_reload_p (unsigned int regno, unsigned int endregno,
|
refers_to_regno_for_reload_p (unsigned int regno, unsigned int endregno,
|
rtx x, rtx *loc)
|
rtx x, rtx *loc)
|
{
|
{
|
int i;
|
int i;
|
unsigned int r;
|
unsigned int r;
|
RTX_CODE code;
|
RTX_CODE code;
|
const char *fmt;
|
const char *fmt;
|
|
|
if (x == 0)
|
if (x == 0)
|
return 0;
|
return 0;
|
|
|
repeat:
|
repeat:
|
code = GET_CODE (x);
|
code = GET_CODE (x);
|
|
|
switch (code)
|
switch (code)
|
{
|
{
|
case REG:
|
case REG:
|
r = REGNO (x);
|
r = REGNO (x);
|
|
|
/* If this is a pseudo, a hard register must not have been allocated.
|
/* If this is a pseudo, a hard register must not have been allocated.
|
X must therefore either be a constant or be in memory. */
|
X must therefore either be a constant or be in memory. */
|
if (r >= FIRST_PSEUDO_REGISTER)
|
if (r >= FIRST_PSEUDO_REGISTER)
|
{
|
{
|
if (reg_equiv_memory_loc[r])
|
if (reg_equiv_memory_loc[r])
|
return refers_to_regno_for_reload_p (regno, endregno,
|
return refers_to_regno_for_reload_p (regno, endregno,
|
reg_equiv_memory_loc[r],
|
reg_equiv_memory_loc[r],
|
(rtx*) 0);
|
(rtx*) 0);
|
|
|
gcc_assert (reg_equiv_constant[r] || reg_equiv_invariant[r]);
|
gcc_assert (reg_equiv_constant[r] || reg_equiv_invariant[r]);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
return (endregno > r
|
return (endregno > r
|
&& regno < r + (r < FIRST_PSEUDO_REGISTER
|
&& regno < r + (r < FIRST_PSEUDO_REGISTER
|
? hard_regno_nregs[r][GET_MODE (x)]
|
? hard_regno_nregs[r][GET_MODE (x)]
|
: 1));
|
: 1));
|
|
|
case SUBREG:
|
case SUBREG:
|
/* If this is a SUBREG of a hard reg, we can see exactly which
|
/* If this is a SUBREG of a hard reg, we can see exactly which
|
registers are being modified. Otherwise, handle normally. */
|
registers are being modified. Otherwise, handle normally. */
|
if (REG_P (SUBREG_REG (x))
|
if (REG_P (SUBREG_REG (x))
|
&& REGNO (SUBREG_REG (x)) < FIRST_PSEUDO_REGISTER)
|
&& REGNO (SUBREG_REG (x)) < FIRST_PSEUDO_REGISTER)
|
{
|
{
|
unsigned int inner_regno = subreg_regno (x);
|
unsigned int inner_regno = subreg_regno (x);
|
unsigned int inner_endregno
|
unsigned int inner_endregno
|
= inner_regno + (inner_regno < FIRST_PSEUDO_REGISTER
|
= inner_regno + (inner_regno < FIRST_PSEUDO_REGISTER
|
? hard_regno_nregs[inner_regno][GET_MODE (x)] : 1);
|
? hard_regno_nregs[inner_regno][GET_MODE (x)] : 1);
|
|
|
return endregno > inner_regno && regno < inner_endregno;
|
return endregno > inner_regno && regno < inner_endregno;
|
}
|
}
|
break;
|
break;
|
|
|
case CLOBBER:
|
case CLOBBER:
|
case SET:
|
case SET:
|
if (&SET_DEST (x) != loc
|
if (&SET_DEST (x) != loc
|
/* Note setting a SUBREG counts as referring to the REG it is in for
|
/* Note setting a SUBREG counts as referring to the REG it is in for
|
a pseudo but not for hard registers since we can
|
a pseudo but not for hard registers since we can
|
treat each word individually. */
|
treat each word individually. */
|
&& ((GET_CODE (SET_DEST (x)) == SUBREG
|
&& ((GET_CODE (SET_DEST (x)) == SUBREG
|
&& loc != &SUBREG_REG (SET_DEST (x))
|
&& loc != &SUBREG_REG (SET_DEST (x))
|
&& REG_P (SUBREG_REG (SET_DEST (x)))
|
&& REG_P (SUBREG_REG (SET_DEST (x)))
|
&& REGNO (SUBREG_REG (SET_DEST (x))) >= FIRST_PSEUDO_REGISTER
|
&& REGNO (SUBREG_REG (SET_DEST (x))) >= FIRST_PSEUDO_REGISTER
|
&& refers_to_regno_for_reload_p (regno, endregno,
|
&& refers_to_regno_for_reload_p (regno, endregno,
|
SUBREG_REG (SET_DEST (x)),
|
SUBREG_REG (SET_DEST (x)),
|
loc))
|
loc))
|
/* If the output is an earlyclobber operand, this is
|
/* If the output is an earlyclobber operand, this is
|
a conflict. */
|
a conflict. */
|
|| ((!REG_P (SET_DEST (x))
|
|| ((!REG_P (SET_DEST (x))
|
|| earlyclobber_operand_p (SET_DEST (x)))
|
|| earlyclobber_operand_p (SET_DEST (x)))
|
&& refers_to_regno_for_reload_p (regno, endregno,
|
&& refers_to_regno_for_reload_p (regno, endregno,
|
SET_DEST (x), loc))))
|
SET_DEST (x), loc))))
|
return 1;
|
return 1;
|
|
|
if (code == CLOBBER || loc == &SET_SRC (x))
|
if (code == CLOBBER || loc == &SET_SRC (x))
|
return 0;
|
return 0;
|
x = SET_SRC (x);
|
x = SET_SRC (x);
|
goto repeat;
|
goto repeat;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
/* X does not match, so try its subexpressions. */
|
/* X does not match, so try its subexpressions. */
|
|
|
fmt = GET_RTX_FORMAT (code);
|
fmt = GET_RTX_FORMAT (code);
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
{
|
{
|
if (fmt[i] == 'e' && loc != &XEXP (x, i))
|
if (fmt[i] == 'e' && loc != &XEXP (x, i))
|
{
|
{
|
if (i == 0)
|
if (i == 0)
|
{
|
{
|
x = XEXP (x, 0);
|
x = XEXP (x, 0);
|
goto repeat;
|
goto repeat;
|
}
|
}
|
else
|
else
|
if (refers_to_regno_for_reload_p (regno, endregno,
|
if (refers_to_regno_for_reload_p (regno, endregno,
|
XEXP (x, i), loc))
|
XEXP (x, i), loc))
|
return 1;
|
return 1;
|
}
|
}
|
else if (fmt[i] == 'E')
|
else if (fmt[i] == 'E')
|
{
|
{
|
int j;
|
int j;
|
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
if (loc != &XVECEXP (x, i, j)
|
if (loc != &XVECEXP (x, i, j)
|
&& refers_to_regno_for_reload_p (regno, endregno,
|
&& refers_to_regno_for_reload_p (regno, endregno,
|
XVECEXP (x, i, j), loc))
|
XVECEXP (x, i, j), loc))
|
return 1;
|
return 1;
|
}
|
}
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Nonzero if modifying X will affect IN. If X is a register or a SUBREG,
|
/* Nonzero if modifying X will affect IN. If X is a register or a SUBREG,
|
we check if any register number in X conflicts with the relevant register
|
we check if any register number in X conflicts with the relevant register
|
numbers. If X is a constant, return 0. If X is a MEM, return 1 iff IN
|
numbers. If X is a constant, return 0. If X is a MEM, return 1 iff IN
|
contains a MEM (we don't bother checking for memory addresses that can't
|
contains a MEM (we don't bother checking for memory addresses that can't
|
conflict because we expect this to be a rare case.
|
conflict because we expect this to be a rare case.
|
|
|
This function is similar to reg_overlap_mentioned_p in rtlanal.c except
|
This function is similar to reg_overlap_mentioned_p in rtlanal.c except
|
that we look at equivalences for pseudos that didn't get hard registers. */
|
that we look at equivalences for pseudos that didn't get hard registers. */
|
|
|
int
|
int
|
reg_overlap_mentioned_for_reload_p (rtx x, rtx in)
|
reg_overlap_mentioned_for_reload_p (rtx x, rtx in)
|
{
|
{
|
int regno, endregno;
|
int regno, endregno;
|
|
|
/* Overly conservative. */
|
/* Overly conservative. */
|
if (GET_CODE (x) == STRICT_LOW_PART
|
if (GET_CODE (x) == STRICT_LOW_PART
|
|| GET_RTX_CLASS (GET_CODE (x)) == RTX_AUTOINC)
|
|| GET_RTX_CLASS (GET_CODE (x)) == RTX_AUTOINC)
|
x = XEXP (x, 0);
|
x = XEXP (x, 0);
|
|
|
/* If either argument is a constant, then modifying X can not affect IN. */
|
/* If either argument is a constant, then modifying X can not affect IN. */
|
if (CONSTANT_P (x) || CONSTANT_P (in))
|
if (CONSTANT_P (x) || CONSTANT_P (in))
|
return 0;
|
return 0;
|
else if (GET_CODE (x) == SUBREG && GET_CODE (SUBREG_REG (x)) == MEM)
|
else if (GET_CODE (x) == SUBREG && GET_CODE (SUBREG_REG (x)) == MEM)
|
return refers_to_mem_for_reload_p (in);
|
return refers_to_mem_for_reload_p (in);
|
else if (GET_CODE (x) == SUBREG)
|
else if (GET_CODE (x) == SUBREG)
|
{
|
{
|
regno = REGNO (SUBREG_REG (x));
|
regno = REGNO (SUBREG_REG (x));
|
if (regno < FIRST_PSEUDO_REGISTER)
|
if (regno < FIRST_PSEUDO_REGISTER)
|
regno += subreg_regno_offset (REGNO (SUBREG_REG (x)),
|
regno += subreg_regno_offset (REGNO (SUBREG_REG (x)),
|
GET_MODE (SUBREG_REG (x)),
|
GET_MODE (SUBREG_REG (x)),
|
SUBREG_BYTE (x),
|
SUBREG_BYTE (x),
|
GET_MODE (x));
|
GET_MODE (x));
|
}
|
}
|
else if (REG_P (x))
|
else if (REG_P (x))
|
{
|
{
|
regno = REGNO (x);
|
regno = REGNO (x);
|
|
|
/* If this is a pseudo, it must not have been assigned a hard register.
|
/* If this is a pseudo, it must not have been assigned a hard register.
|
Therefore, it must either be in memory or be a constant. */
|
Therefore, it must either be in memory or be a constant. */
|
|
|
if (regno >= FIRST_PSEUDO_REGISTER)
|
if (regno >= FIRST_PSEUDO_REGISTER)
|
{
|
{
|
if (reg_equiv_memory_loc[regno])
|
if (reg_equiv_memory_loc[regno])
|
return refers_to_mem_for_reload_p (in);
|
return refers_to_mem_for_reload_p (in);
|
gcc_assert (reg_equiv_constant[regno]);
|
gcc_assert (reg_equiv_constant[regno]);
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
else if (MEM_P (x))
|
else if (MEM_P (x))
|
return refers_to_mem_for_reload_p (in);
|
return refers_to_mem_for_reload_p (in);
|
else if (GET_CODE (x) == SCRATCH || GET_CODE (x) == PC
|
else if (GET_CODE (x) == SCRATCH || GET_CODE (x) == PC
|
|| GET_CODE (x) == CC0)
|
|| GET_CODE (x) == CC0)
|
return reg_mentioned_p (x, in);
|
return reg_mentioned_p (x, in);
|
else
|
else
|
{
|
{
|
gcc_assert (GET_CODE (x) == PLUS);
|
gcc_assert (GET_CODE (x) == PLUS);
|
|
|
/* We actually want to know if X is mentioned somewhere inside IN.
|
/* We actually want to know if X is mentioned somewhere inside IN.
|
We must not say that (plus (sp) (const_int 124)) is in
|
We must not say that (plus (sp) (const_int 124)) is in
|
(plus (sp) (const_int 64)), since that can lead to incorrect reload
|
(plus (sp) (const_int 64)), since that can lead to incorrect reload
|
allocation when spuriously changing a RELOAD_FOR_OUTPUT_ADDRESS
|
allocation when spuriously changing a RELOAD_FOR_OUTPUT_ADDRESS
|
into a RELOAD_OTHER on behalf of another RELOAD_OTHER. */
|
into a RELOAD_OTHER on behalf of another RELOAD_OTHER. */
|
while (MEM_P (in))
|
while (MEM_P (in))
|
in = XEXP (in, 0);
|
in = XEXP (in, 0);
|
if (REG_P (in))
|
if (REG_P (in))
|
return 0;
|
return 0;
|
else if (GET_CODE (in) == PLUS)
|
else if (GET_CODE (in) == PLUS)
|
return (rtx_equal_p (x, in)
|
return (rtx_equal_p (x, in)
|
|| reg_overlap_mentioned_for_reload_p (x, XEXP (in, 0))
|
|| reg_overlap_mentioned_for_reload_p (x, XEXP (in, 0))
|
|| reg_overlap_mentioned_for_reload_p (x, XEXP (in, 1)));
|
|| reg_overlap_mentioned_for_reload_p (x, XEXP (in, 1)));
|
else return (reg_overlap_mentioned_for_reload_p (XEXP (x, 0), in)
|
else return (reg_overlap_mentioned_for_reload_p (XEXP (x, 0), in)
|
|| reg_overlap_mentioned_for_reload_p (XEXP (x, 1), in));
|
|| reg_overlap_mentioned_for_reload_p (XEXP (x, 1), in));
|
}
|
}
|
|
|
endregno = regno + (regno < FIRST_PSEUDO_REGISTER
|
endregno = regno + (regno < FIRST_PSEUDO_REGISTER
|
? hard_regno_nregs[regno][GET_MODE (x)] : 1);
|
? hard_regno_nregs[regno][GET_MODE (x)] : 1);
|
|
|
return refers_to_regno_for_reload_p (regno, endregno, in, (rtx*) 0);
|
return refers_to_regno_for_reload_p (regno, endregno, in, (rtx*) 0);
|
}
|
}
|
|
|
/* Return nonzero if anything in X contains a MEM. Look also for pseudo
|
/* Return nonzero if anything in X contains a MEM. Look also for pseudo
|
registers. */
|
registers. */
|
|
|
static int
|
static int
|
refers_to_mem_for_reload_p (rtx x)
|
refers_to_mem_for_reload_p (rtx x)
|
{
|
{
|
const char *fmt;
|
const char *fmt;
|
int i;
|
int i;
|
|
|
if (MEM_P (x))
|
if (MEM_P (x))
|
return 1;
|
return 1;
|
|
|
if (REG_P (x))
|
if (REG_P (x))
|
return (REGNO (x) >= FIRST_PSEUDO_REGISTER
|
return (REGNO (x) >= FIRST_PSEUDO_REGISTER
|
&& reg_equiv_memory_loc[REGNO (x)]);
|
&& reg_equiv_memory_loc[REGNO (x)]);
|
|
|
fmt = GET_RTX_FORMAT (GET_CODE (x));
|
fmt = GET_RTX_FORMAT (GET_CODE (x));
|
for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
|
for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
|
if (fmt[i] == 'e'
|
if (fmt[i] == 'e'
|
&& (MEM_P (XEXP (x, i))
|
&& (MEM_P (XEXP (x, i))
|
|| refers_to_mem_for_reload_p (XEXP (x, i))))
|
|| refers_to_mem_for_reload_p (XEXP (x, i))))
|
return 1;
|
return 1;
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Check the insns before INSN to see if there is a suitable register
|
/* Check the insns before INSN to see if there is a suitable register
|
containing the same value as GOAL.
|
containing the same value as GOAL.
|
If OTHER is -1, look for a register in class CLASS.
|
If OTHER is -1, look for a register in class CLASS.
|
Otherwise, just see if register number OTHER shares GOAL's value.
|
Otherwise, just see if register number OTHER shares GOAL's value.
|
|
|
Return an rtx for the register found, or zero if none is found.
|
Return an rtx for the register found, or zero if none is found.
|
|
|
If RELOAD_REG_P is (short *)1,
|
If RELOAD_REG_P is (short *)1,
|
we reject any hard reg that appears in reload_reg_rtx
|
we reject any hard reg that appears in reload_reg_rtx
|
because such a hard reg is also needed coming into this insn.
|
because such a hard reg is also needed coming into this insn.
|
|
|
If RELOAD_REG_P is any other nonzero value,
|
If RELOAD_REG_P is any other nonzero value,
|
it is a vector indexed by hard reg number
|
it is a vector indexed by hard reg number
|
and we reject any hard reg whose element in the vector is nonnegative
|
and we reject any hard reg whose element in the vector is nonnegative
|
as well as any that appears in reload_reg_rtx.
|
as well as any that appears in reload_reg_rtx.
|
|
|
If GOAL is zero, then GOALREG is a register number; we look
|
If GOAL is zero, then GOALREG is a register number; we look
|
for an equivalent for that register.
|
for an equivalent for that register.
|
|
|
MODE is the machine mode of the value we want an equivalence for.
|
MODE is the machine mode of the value we want an equivalence for.
|
If GOAL is nonzero and not VOIDmode, then it must have mode MODE.
|
If GOAL is nonzero and not VOIDmode, then it must have mode MODE.
|
|
|
This function is used by jump.c as well as in the reload pass.
|
This function is used by jump.c as well as in the reload pass.
|
|
|
If GOAL is the sum of the stack pointer and a constant, we treat it
|
If GOAL is the sum of the stack pointer and a constant, we treat it
|
as if it were a constant except that sp is required to be unchanging. */
|
as if it were a constant except that sp is required to be unchanging. */
|
|
|
rtx
|
rtx
|
find_equiv_reg (rtx goal, rtx insn, enum reg_class class, int other,
|
find_equiv_reg (rtx goal, rtx insn, enum reg_class class, int other,
|
short *reload_reg_p, int goalreg, enum machine_mode mode)
|
short *reload_reg_p, int goalreg, enum machine_mode mode)
|
{
|
{
|
rtx p = insn;
|
rtx p = insn;
|
rtx goaltry, valtry, value, where;
|
rtx goaltry, valtry, value, where;
|
rtx pat;
|
rtx pat;
|
int regno = -1;
|
int regno = -1;
|
int valueno;
|
int valueno;
|
int goal_mem = 0;
|
int goal_mem = 0;
|
int goal_const = 0;
|
int goal_const = 0;
|
int goal_mem_addr_varies = 0;
|
int goal_mem_addr_varies = 0;
|
int need_stable_sp = 0;
|
int need_stable_sp = 0;
|
int nregs;
|
int nregs;
|
int valuenregs;
|
int valuenregs;
|
int num = 0;
|
int num = 0;
|
|
|
if (goal == 0)
|
if (goal == 0)
|
regno = goalreg;
|
regno = goalreg;
|
else if (REG_P (goal))
|
else if (REG_P (goal))
|
regno = REGNO (goal);
|
regno = REGNO (goal);
|
else if (MEM_P (goal))
|
else if (MEM_P (goal))
|
{
|
{
|
enum rtx_code code = GET_CODE (XEXP (goal, 0));
|
enum rtx_code code = GET_CODE (XEXP (goal, 0));
|
if (MEM_VOLATILE_P (goal))
|
if (MEM_VOLATILE_P (goal))
|
return 0;
|
return 0;
|
if (flag_float_store && SCALAR_FLOAT_MODE_P (GET_MODE (goal)))
|
if (flag_float_store && SCALAR_FLOAT_MODE_P (GET_MODE (goal)))
|
return 0;
|
return 0;
|
/* An address with side effects must be reexecuted. */
|
/* An address with side effects must be reexecuted. */
|
switch (code)
|
switch (code)
|
{
|
{
|
case POST_INC:
|
case POST_INC:
|
case PRE_INC:
|
case PRE_INC:
|
case POST_DEC:
|
case POST_DEC:
|
case PRE_DEC:
|
case PRE_DEC:
|
case POST_MODIFY:
|
case POST_MODIFY:
|
case PRE_MODIFY:
|
case PRE_MODIFY:
|
return 0;
|
return 0;
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
goal_mem = 1;
|
goal_mem = 1;
|
}
|
}
|
else if (CONSTANT_P (goal))
|
else if (CONSTANT_P (goal))
|
goal_const = 1;
|
goal_const = 1;
|
else if (GET_CODE (goal) == PLUS
|
else if (GET_CODE (goal) == PLUS
|
&& XEXP (goal, 0) == stack_pointer_rtx
|
&& XEXP (goal, 0) == stack_pointer_rtx
|
&& CONSTANT_P (XEXP (goal, 1)))
|
&& CONSTANT_P (XEXP (goal, 1)))
|
goal_const = need_stable_sp = 1;
|
goal_const = need_stable_sp = 1;
|
else if (GET_CODE (goal) == PLUS
|
else if (GET_CODE (goal) == PLUS
|
&& XEXP (goal, 0) == frame_pointer_rtx
|
&& XEXP (goal, 0) == frame_pointer_rtx
|
&& CONSTANT_P (XEXP (goal, 1)))
|
&& CONSTANT_P (XEXP (goal, 1)))
|
goal_const = 1;
|
goal_const = 1;
|
else
|
else
|
return 0;
|
return 0;
|
|
|
num = 0;
|
num = 0;
|
/* Scan insns back from INSN, looking for one that copies
|
/* Scan insns back from INSN, looking for one that copies
|
a value into or out of GOAL.
|
a value into or out of GOAL.
|
Stop and give up if we reach a label. */
|
Stop and give up if we reach a label. */
|
|
|
while (1)
|
while (1)
|
{
|
{
|
p = PREV_INSN (p);
|
p = PREV_INSN (p);
|
num++;
|
num++;
|
if (p == 0 || LABEL_P (p)
|
if (p == 0 || LABEL_P (p)
|
|| num > PARAM_VALUE (PARAM_MAX_RELOAD_SEARCH_INSNS))
|
|| num > PARAM_VALUE (PARAM_MAX_RELOAD_SEARCH_INSNS))
|
return 0;
|
return 0;
|
|
|
if (NONJUMP_INSN_P (p)
|
if (NONJUMP_INSN_P (p)
|
/* If we don't want spill regs ... */
|
/* If we don't want spill regs ... */
|
&& (! (reload_reg_p != 0
|
&& (! (reload_reg_p != 0
|
&& reload_reg_p != (short *) (HOST_WIDE_INT) 1)
|
&& reload_reg_p != (short *) (HOST_WIDE_INT) 1)
|
/* ... then ignore insns introduced by reload; they aren't
|
/* ... then ignore insns introduced by reload; they aren't
|
useful and can cause results in reload_as_needed to be
|
useful and can cause results in reload_as_needed to be
|
different from what they were when calculating the need for
|
different from what they were when calculating the need for
|
spills. If we notice an input-reload insn here, we will
|
spills. If we notice an input-reload insn here, we will
|
reject it below, but it might hide a usable equivalent.
|
reject it below, but it might hide a usable equivalent.
|
That makes bad code. It may even fail: perhaps no reg was
|
That makes bad code. It may even fail: perhaps no reg was
|
spilled for this insn because it was assumed we would find
|
spilled for this insn because it was assumed we would find
|
that equivalent. */
|
that equivalent. */
|
|| INSN_UID (p) < reload_first_uid))
|
|| INSN_UID (p) < reload_first_uid))
|
{
|
{
|
rtx tem;
|
rtx tem;
|
pat = single_set (p);
|
pat = single_set (p);
|
|
|
/* First check for something that sets some reg equal to GOAL. */
|
/* First check for something that sets some reg equal to GOAL. */
|
if (pat != 0
|
if (pat != 0
|
&& ((regno >= 0
|
&& ((regno >= 0
|
&& true_regnum (SET_SRC (pat)) == regno
|
&& true_regnum (SET_SRC (pat)) == regno
|
&& (valueno = true_regnum (valtry = SET_DEST (pat))) >= 0)
|
&& (valueno = true_regnum (valtry = SET_DEST (pat))) >= 0)
|
||
|
||
|
(regno >= 0
|
(regno >= 0
|
&& true_regnum (SET_DEST (pat)) == regno
|
&& true_regnum (SET_DEST (pat)) == regno
|
&& (valueno = true_regnum (valtry = SET_SRC (pat))) >= 0)
|
&& (valueno = true_regnum (valtry = SET_SRC (pat))) >= 0)
|
||
|
||
|
(goal_const && rtx_equal_p (SET_SRC (pat), goal)
|
(goal_const && rtx_equal_p (SET_SRC (pat), goal)
|
/* When looking for stack pointer + const,
|
/* When looking for stack pointer + const,
|
make sure we don't use a stack adjust. */
|
make sure we don't use a stack adjust. */
|
&& !reg_overlap_mentioned_for_reload_p (SET_DEST (pat), goal)
|
&& !reg_overlap_mentioned_for_reload_p (SET_DEST (pat), goal)
|
&& (valueno = true_regnum (valtry = SET_DEST (pat))) >= 0)
|
&& (valueno = true_regnum (valtry = SET_DEST (pat))) >= 0)
|
|| (goal_mem
|
|| (goal_mem
|
&& (valueno = true_regnum (valtry = SET_DEST (pat))) >= 0
|
&& (valueno = true_regnum (valtry = SET_DEST (pat))) >= 0
|
&& rtx_renumbered_equal_p (goal, SET_SRC (pat)))
|
&& rtx_renumbered_equal_p (goal, SET_SRC (pat)))
|
|| (goal_mem
|
|| (goal_mem
|
&& (valueno = true_regnum (valtry = SET_SRC (pat))) >= 0
|
&& (valueno = true_regnum (valtry = SET_SRC (pat))) >= 0
|
&& rtx_renumbered_equal_p (goal, SET_DEST (pat)))
|
&& rtx_renumbered_equal_p (goal, SET_DEST (pat)))
|
/* If we are looking for a constant,
|
/* If we are looking for a constant,
|
and something equivalent to that constant was copied
|
and something equivalent to that constant was copied
|
into a reg, we can use that reg. */
|
into a reg, we can use that reg. */
|
|| (goal_const && REG_NOTES (p) != 0
|
|| (goal_const && REG_NOTES (p) != 0
|
&& (tem = find_reg_note (p, REG_EQUIV, NULL_RTX))
|
&& (tem = find_reg_note (p, REG_EQUIV, NULL_RTX))
|
&& ((rtx_equal_p (XEXP (tem, 0), goal)
|
&& ((rtx_equal_p (XEXP (tem, 0), goal)
|
&& (valueno
|
&& (valueno
|
= true_regnum (valtry = SET_DEST (pat))) >= 0)
|
= true_regnum (valtry = SET_DEST (pat))) >= 0)
|
|| (REG_P (SET_DEST (pat))
|
|| (REG_P (SET_DEST (pat))
|
&& GET_CODE (XEXP (tem, 0)) == CONST_DOUBLE
|
&& GET_CODE (XEXP (tem, 0)) == CONST_DOUBLE
|
&& SCALAR_FLOAT_MODE_P (GET_MODE (XEXP (tem, 0)))
|
&& SCALAR_FLOAT_MODE_P (GET_MODE (XEXP (tem, 0)))
|
&& GET_CODE (goal) == CONST_INT
|
&& GET_CODE (goal) == CONST_INT
|
&& 0 != (goaltry
|
&& 0 != (goaltry
|
= operand_subword (XEXP (tem, 0), 0, 0,
|
= operand_subword (XEXP (tem, 0), 0, 0,
|
VOIDmode))
|
VOIDmode))
|
&& rtx_equal_p (goal, goaltry)
|
&& rtx_equal_p (goal, goaltry)
|
&& (valtry
|
&& (valtry
|
= operand_subword (SET_DEST (pat), 0, 0,
|
= operand_subword (SET_DEST (pat), 0, 0,
|
VOIDmode))
|
VOIDmode))
|
&& (valueno = true_regnum (valtry)) >= 0)))
|
&& (valueno = true_regnum (valtry)) >= 0)))
|
|| (goal_const && (tem = find_reg_note (p, REG_EQUIV,
|
|| (goal_const && (tem = find_reg_note (p, REG_EQUIV,
|
NULL_RTX))
|
NULL_RTX))
|
&& REG_P (SET_DEST (pat))
|
&& REG_P (SET_DEST (pat))
|
&& GET_CODE (XEXP (tem, 0)) == CONST_DOUBLE
|
&& GET_CODE (XEXP (tem, 0)) == CONST_DOUBLE
|
&& SCALAR_FLOAT_MODE_P (GET_MODE (XEXP (tem, 0)))
|
&& SCALAR_FLOAT_MODE_P (GET_MODE (XEXP (tem, 0)))
|
&& GET_CODE (goal) == CONST_INT
|
&& GET_CODE (goal) == CONST_INT
|
&& 0 != (goaltry = operand_subword (XEXP (tem, 0), 1, 0,
|
&& 0 != (goaltry = operand_subword (XEXP (tem, 0), 1, 0,
|
VOIDmode))
|
VOIDmode))
|
&& rtx_equal_p (goal, goaltry)
|
&& rtx_equal_p (goal, goaltry)
|
&& (valtry
|
&& (valtry
|
= operand_subword (SET_DEST (pat), 1, 0, VOIDmode))
|
= operand_subword (SET_DEST (pat), 1, 0, VOIDmode))
|
&& (valueno = true_regnum (valtry)) >= 0)))
|
&& (valueno = true_regnum (valtry)) >= 0)))
|
{
|
{
|
if (other >= 0)
|
if (other >= 0)
|
{
|
{
|
if (valueno != other)
|
if (valueno != other)
|
continue;
|
continue;
|
}
|
}
|
else if ((unsigned) valueno >= FIRST_PSEUDO_REGISTER)
|
else if ((unsigned) valueno >= FIRST_PSEUDO_REGISTER)
|
continue;
|
continue;
|
else
|
else
|
{
|
{
|
int i;
|
int i;
|
|
|
for (i = hard_regno_nregs[valueno][mode] - 1; i >= 0; i--)
|
for (i = hard_regno_nregs[valueno][mode] - 1; i >= 0; i--)
|
if (! TEST_HARD_REG_BIT (reg_class_contents[(int) class],
|
if (! TEST_HARD_REG_BIT (reg_class_contents[(int) class],
|
valueno + i))
|
valueno + i))
|
break;
|
break;
|
if (i >= 0)
|
if (i >= 0)
|
continue;
|
continue;
|
}
|
}
|
value = valtry;
|
value = valtry;
|
where = p;
|
where = p;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* We found a previous insn copying GOAL into a suitable other reg VALUE
|
/* We found a previous insn copying GOAL into a suitable other reg VALUE
|
(or copying VALUE into GOAL, if GOAL is also a register).
|
(or copying VALUE into GOAL, if GOAL is also a register).
|
Now verify that VALUE is really valid. */
|
Now verify that VALUE is really valid. */
|
|
|
/* VALUENO is the register number of VALUE; a hard register. */
|
/* VALUENO is the register number of VALUE; a hard register. */
|
|
|
/* Don't try to re-use something that is killed in this insn. We want
|
/* Don't try to re-use something that is killed in this insn. We want
|
to be able to trust REG_UNUSED notes. */
|
to be able to trust REG_UNUSED notes. */
|
if (REG_NOTES (where) != 0 && find_reg_note (where, REG_UNUSED, value))
|
if (REG_NOTES (where) != 0 && find_reg_note (where, REG_UNUSED, value))
|
return 0;
|
return 0;
|
|
|
/* If we propose to get the value from the stack pointer or if GOAL is
|
/* If we propose to get the value from the stack pointer or if GOAL is
|
a MEM based on the stack pointer, we need a stable SP. */
|
a MEM based on the stack pointer, we need a stable SP. */
|
if (valueno == STACK_POINTER_REGNUM || regno == STACK_POINTER_REGNUM
|
if (valueno == STACK_POINTER_REGNUM || regno == STACK_POINTER_REGNUM
|
|| (goal_mem && reg_overlap_mentioned_for_reload_p (stack_pointer_rtx,
|
|| (goal_mem && reg_overlap_mentioned_for_reload_p (stack_pointer_rtx,
|
goal)))
|
goal)))
|
need_stable_sp = 1;
|
need_stable_sp = 1;
|
|
|
/* Reject VALUE if the copy-insn moved the wrong sort of datum. */
|
/* Reject VALUE if the copy-insn moved the wrong sort of datum. */
|
if (GET_MODE (value) != mode)
|
if (GET_MODE (value) != mode)
|
return 0;
|
return 0;
|
|
|
/* Reject VALUE if it was loaded from GOAL
|
/* Reject VALUE if it was loaded from GOAL
|
and is also a register that appears in the address of GOAL. */
|
and is also a register that appears in the address of GOAL. */
|
|
|
if (goal_mem && value == SET_DEST (single_set (where))
|
if (goal_mem && value == SET_DEST (single_set (where))
|
&& refers_to_regno_for_reload_p (valueno,
|
&& refers_to_regno_for_reload_p (valueno,
|
(valueno
|
(valueno
|
+ hard_regno_nregs[valueno][mode]),
|
+ hard_regno_nregs[valueno][mode]),
|
goal, (rtx*) 0))
|
goal, (rtx*) 0))
|
return 0;
|
return 0;
|
|
|
/* Reject registers that overlap GOAL. */
|
/* Reject registers that overlap GOAL. */
|
|
|
if (regno >= 0 && regno < FIRST_PSEUDO_REGISTER)
|
if (regno >= 0 && regno < FIRST_PSEUDO_REGISTER)
|
nregs = hard_regno_nregs[regno][mode];
|
nregs = hard_regno_nregs[regno][mode];
|
else
|
else
|
nregs = 1;
|
nregs = 1;
|
valuenregs = hard_regno_nregs[valueno][mode];
|
valuenregs = hard_regno_nregs[valueno][mode];
|
|
|
if (!goal_mem && !goal_const
|
if (!goal_mem && !goal_const
|
&& regno + nregs > valueno && regno < valueno + valuenregs)
|
&& regno + nregs > valueno && regno < valueno + valuenregs)
|
return 0;
|
return 0;
|
|
|
/* Reject VALUE if it is one of the regs reserved for reloads.
|
/* Reject VALUE if it is one of the regs reserved for reloads.
|
Reload1 knows how to reuse them anyway, and it would get
|
Reload1 knows how to reuse them anyway, and it would get
|
confused if we allocated one without its knowledge.
|
confused if we allocated one without its knowledge.
|
(Now that insns introduced by reload are ignored above,
|
(Now that insns introduced by reload are ignored above,
|
this case shouldn't happen, but I'm not positive.) */
|
this case shouldn't happen, but I'm not positive.) */
|
|
|
if (reload_reg_p != 0 && reload_reg_p != (short *) (HOST_WIDE_INT) 1)
|
if (reload_reg_p != 0 && reload_reg_p != (short *) (HOST_WIDE_INT) 1)
|
{
|
{
|
int i;
|
int i;
|
for (i = 0; i < valuenregs; ++i)
|
for (i = 0; i < valuenregs; ++i)
|
if (reload_reg_p[valueno + i] >= 0)
|
if (reload_reg_p[valueno + i] >= 0)
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Reject VALUE if it is a register being used for an input reload
|
/* Reject VALUE if it is a register being used for an input reload
|
even if it is not one of those reserved. */
|
even if it is not one of those reserved. */
|
|
|
if (reload_reg_p != 0)
|
if (reload_reg_p != 0)
|
{
|
{
|
int i;
|
int i;
|
for (i = 0; i < n_reloads; i++)
|
for (i = 0; i < n_reloads; i++)
|
if (rld[i].reg_rtx != 0 && rld[i].in)
|
if (rld[i].reg_rtx != 0 && rld[i].in)
|
{
|
{
|
int regno1 = REGNO (rld[i].reg_rtx);
|
int regno1 = REGNO (rld[i].reg_rtx);
|
int nregs1 = hard_regno_nregs[regno1]
|
int nregs1 = hard_regno_nregs[regno1]
|
[GET_MODE (rld[i].reg_rtx)];
|
[GET_MODE (rld[i].reg_rtx)];
|
if (regno1 < valueno + valuenregs
|
if (regno1 < valueno + valuenregs
|
&& regno1 + nregs1 > valueno)
|
&& regno1 + nregs1 > valueno)
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
|
|
if (goal_mem)
|
if (goal_mem)
|
/* We must treat frame pointer as varying here,
|
/* We must treat frame pointer as varying here,
|
since it can vary--in a nonlocal goto as generated by expand_goto. */
|
since it can vary--in a nonlocal goto as generated by expand_goto. */
|
goal_mem_addr_varies = !CONSTANT_ADDRESS_P (XEXP (goal, 0));
|
goal_mem_addr_varies = !CONSTANT_ADDRESS_P (XEXP (goal, 0));
|
|
|
/* Now verify that the values of GOAL and VALUE remain unaltered
|
/* Now verify that the values of GOAL and VALUE remain unaltered
|
until INSN is reached. */
|
until INSN is reached. */
|
|
|
p = insn;
|
p = insn;
|
while (1)
|
while (1)
|
{
|
{
|
p = PREV_INSN (p);
|
p = PREV_INSN (p);
|
if (p == where)
|
if (p == where)
|
return value;
|
return value;
|
|
|
/* Don't trust the conversion past a function call
|
/* Don't trust the conversion past a function call
|
if either of the two is in a call-clobbered register, or memory. */
|
if either of the two is in a call-clobbered register, or memory. */
|
if (CALL_P (p))
|
if (CALL_P (p))
|
{
|
{
|
int i;
|
int i;
|
|
|
if (goal_mem || need_stable_sp)
|
if (goal_mem || need_stable_sp)
|
return 0;
|
return 0;
|
|
|
if (regno >= 0 && regno < FIRST_PSEUDO_REGISTER)
|
if (regno >= 0 && regno < FIRST_PSEUDO_REGISTER)
|
for (i = 0; i < nregs; ++i)
|
for (i = 0; i < nregs; ++i)
|
if (call_used_regs[regno + i]
|
if (call_used_regs[regno + i]
|
|| HARD_REGNO_CALL_PART_CLOBBERED (regno + i, mode))
|
|| HARD_REGNO_CALL_PART_CLOBBERED (regno + i, mode))
|
return 0;
|
return 0;
|
|
|
if (valueno >= 0 && valueno < FIRST_PSEUDO_REGISTER)
|
if (valueno >= 0 && valueno < FIRST_PSEUDO_REGISTER)
|
for (i = 0; i < valuenregs; ++i)
|
for (i = 0; i < valuenregs; ++i)
|
if (call_used_regs[valueno + i]
|
if (call_used_regs[valueno + i]
|
|| HARD_REGNO_CALL_PART_CLOBBERED (valueno + i, mode))
|
|| HARD_REGNO_CALL_PART_CLOBBERED (valueno + i, mode))
|
return 0;
|
return 0;
|
}
|
}
|
|
|
if (INSN_P (p))
|
if (INSN_P (p))
|
{
|
{
|
pat = PATTERN (p);
|
pat = PATTERN (p);
|
|
|
/* Watch out for unspec_volatile, and volatile asms. */
|
/* Watch out for unspec_volatile, and volatile asms. */
|
if (volatile_insn_p (pat))
|
if (volatile_insn_p (pat))
|
return 0;
|
return 0;
|
|
|
/* If this insn P stores in either GOAL or VALUE, return 0.
|
/* If this insn P stores in either GOAL or VALUE, return 0.
|
If GOAL is a memory ref and this insn writes memory, return 0.
|
If GOAL is a memory ref and this insn writes memory, return 0.
|
If GOAL is a memory ref and its address is not constant,
|
If GOAL is a memory ref and its address is not constant,
|
and this insn P changes a register used in GOAL, return 0. */
|
and this insn P changes a register used in GOAL, return 0. */
|
|
|
if (GET_CODE (pat) == COND_EXEC)
|
if (GET_CODE (pat) == COND_EXEC)
|
pat = COND_EXEC_CODE (pat);
|
pat = COND_EXEC_CODE (pat);
|
if (GET_CODE (pat) == SET || GET_CODE (pat) == CLOBBER)
|
if (GET_CODE (pat) == SET || GET_CODE (pat) == CLOBBER)
|
{
|
{
|
rtx dest = SET_DEST (pat);
|
rtx dest = SET_DEST (pat);
|
while (GET_CODE (dest) == SUBREG
|
while (GET_CODE (dest) == SUBREG
|
|| GET_CODE (dest) == ZERO_EXTRACT
|
|| GET_CODE (dest) == ZERO_EXTRACT
|
|| GET_CODE (dest) == STRICT_LOW_PART)
|
|| GET_CODE (dest) == STRICT_LOW_PART)
|
dest = XEXP (dest, 0);
|
dest = XEXP (dest, 0);
|
if (REG_P (dest))
|
if (REG_P (dest))
|
{
|
{
|
int xregno = REGNO (dest);
|
int xregno = REGNO (dest);
|
int xnregs;
|
int xnregs;
|
if (REGNO (dest) < FIRST_PSEUDO_REGISTER)
|
if (REGNO (dest) < FIRST_PSEUDO_REGISTER)
|
xnregs = hard_regno_nregs[xregno][GET_MODE (dest)];
|
xnregs = hard_regno_nregs[xregno][GET_MODE (dest)];
|
else
|
else
|
xnregs = 1;
|
xnregs = 1;
|
if (xregno < regno + nregs && xregno + xnregs > regno)
|
if (xregno < regno + nregs && xregno + xnregs > regno)
|
return 0;
|
return 0;
|
if (xregno < valueno + valuenregs
|
if (xregno < valueno + valuenregs
|
&& xregno + xnregs > valueno)
|
&& xregno + xnregs > valueno)
|
return 0;
|
return 0;
|
if (goal_mem_addr_varies
|
if (goal_mem_addr_varies
|
&& reg_overlap_mentioned_for_reload_p (dest, goal))
|
&& reg_overlap_mentioned_for_reload_p (dest, goal))
|
return 0;
|
return 0;
|
if (xregno == STACK_POINTER_REGNUM && need_stable_sp)
|
if (xregno == STACK_POINTER_REGNUM && need_stable_sp)
|
return 0;
|
return 0;
|
}
|
}
|
else if (goal_mem && MEM_P (dest)
|
else if (goal_mem && MEM_P (dest)
|
&& ! push_operand (dest, GET_MODE (dest)))
|
&& ! push_operand (dest, GET_MODE (dest)))
|
return 0;
|
return 0;
|
else if (MEM_P (dest) && regno >= FIRST_PSEUDO_REGISTER
|
else if (MEM_P (dest) && regno >= FIRST_PSEUDO_REGISTER
|
&& reg_equiv_memory_loc[regno] != 0)
|
&& reg_equiv_memory_loc[regno] != 0)
|
return 0;
|
return 0;
|
else if (need_stable_sp && push_operand (dest, GET_MODE (dest)))
|
else if (need_stable_sp && push_operand (dest, GET_MODE (dest)))
|
return 0;
|
return 0;
|
}
|
}
|
else if (GET_CODE (pat) == PARALLEL)
|
else if (GET_CODE (pat) == PARALLEL)
|
{
|
{
|
int i;
|
int i;
|
for (i = XVECLEN (pat, 0) - 1; i >= 0; i--)
|
for (i = XVECLEN (pat, 0) - 1; i >= 0; i--)
|
{
|
{
|
rtx v1 = XVECEXP (pat, 0, i);
|
rtx v1 = XVECEXP (pat, 0, i);
|
if (GET_CODE (v1) == COND_EXEC)
|
if (GET_CODE (v1) == COND_EXEC)
|
v1 = COND_EXEC_CODE (v1);
|
v1 = COND_EXEC_CODE (v1);
|
if (GET_CODE (v1) == SET || GET_CODE (v1) == CLOBBER)
|
if (GET_CODE (v1) == SET || GET_CODE (v1) == CLOBBER)
|
{
|
{
|
rtx dest = SET_DEST (v1);
|
rtx dest = SET_DEST (v1);
|
while (GET_CODE (dest) == SUBREG
|
while (GET_CODE (dest) == SUBREG
|
|| GET_CODE (dest) == ZERO_EXTRACT
|
|| GET_CODE (dest) == ZERO_EXTRACT
|
|| GET_CODE (dest) == STRICT_LOW_PART)
|
|| GET_CODE (dest) == STRICT_LOW_PART)
|
dest = XEXP (dest, 0);
|
dest = XEXP (dest, 0);
|
if (REG_P (dest))
|
if (REG_P (dest))
|
{
|
{
|
int xregno = REGNO (dest);
|
int xregno = REGNO (dest);
|
int xnregs;
|
int xnregs;
|
if (REGNO (dest) < FIRST_PSEUDO_REGISTER)
|
if (REGNO (dest) < FIRST_PSEUDO_REGISTER)
|
xnregs = hard_regno_nregs[xregno][GET_MODE (dest)];
|
xnregs = hard_regno_nregs[xregno][GET_MODE (dest)];
|
else
|
else
|
xnregs = 1;
|
xnregs = 1;
|
if (xregno < regno + nregs
|
if (xregno < regno + nregs
|
&& xregno + xnregs > regno)
|
&& xregno + xnregs > regno)
|
return 0;
|
return 0;
|
if (xregno < valueno + valuenregs
|
if (xregno < valueno + valuenregs
|
&& xregno + xnregs > valueno)
|
&& xregno + xnregs > valueno)
|
return 0;
|
return 0;
|
if (goal_mem_addr_varies
|
if (goal_mem_addr_varies
|
&& reg_overlap_mentioned_for_reload_p (dest,
|
&& reg_overlap_mentioned_for_reload_p (dest,
|
goal))
|
goal))
|
return 0;
|
return 0;
|
if (xregno == STACK_POINTER_REGNUM && need_stable_sp)
|
if (xregno == STACK_POINTER_REGNUM && need_stable_sp)
|
return 0;
|
return 0;
|
}
|
}
|
else if (goal_mem && MEM_P (dest)
|
else if (goal_mem && MEM_P (dest)
|
&& ! push_operand (dest, GET_MODE (dest)))
|
&& ! push_operand (dest, GET_MODE (dest)))
|
return 0;
|
return 0;
|
else if (MEM_P (dest) && regno >= FIRST_PSEUDO_REGISTER
|
else if (MEM_P (dest) && regno >= FIRST_PSEUDO_REGISTER
|
&& reg_equiv_memory_loc[regno] != 0)
|
&& reg_equiv_memory_loc[regno] != 0)
|
return 0;
|
return 0;
|
else if (need_stable_sp
|
else if (need_stable_sp
|
&& push_operand (dest, GET_MODE (dest)))
|
&& push_operand (dest, GET_MODE (dest)))
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
if (CALL_P (p) && CALL_INSN_FUNCTION_USAGE (p))
|
if (CALL_P (p) && CALL_INSN_FUNCTION_USAGE (p))
|
{
|
{
|
rtx link;
|
rtx link;
|
|
|
for (link = CALL_INSN_FUNCTION_USAGE (p); XEXP (link, 1) != 0;
|
for (link = CALL_INSN_FUNCTION_USAGE (p); XEXP (link, 1) != 0;
|
link = XEXP (link, 1))
|
link = XEXP (link, 1))
|
{
|
{
|
pat = XEXP (link, 0);
|
pat = XEXP (link, 0);
|
if (GET_CODE (pat) == CLOBBER)
|
if (GET_CODE (pat) == CLOBBER)
|
{
|
{
|
rtx dest = SET_DEST (pat);
|
rtx dest = SET_DEST (pat);
|
|
|
if (REG_P (dest))
|
if (REG_P (dest))
|
{
|
{
|
int xregno = REGNO (dest);
|
int xregno = REGNO (dest);
|
int xnregs
|
int xnregs
|
= hard_regno_nregs[xregno][GET_MODE (dest)];
|
= hard_regno_nregs[xregno][GET_MODE (dest)];
|
|
|
if (xregno < regno + nregs
|
if (xregno < regno + nregs
|
&& xregno + xnregs > regno)
|
&& xregno + xnregs > regno)
|
return 0;
|
return 0;
|
else if (xregno < valueno + valuenregs
|
else if (xregno < valueno + valuenregs
|
&& xregno + xnregs > valueno)
|
&& xregno + xnregs > valueno)
|
return 0;
|
return 0;
|
else if (goal_mem_addr_varies
|
else if (goal_mem_addr_varies
|
&& reg_overlap_mentioned_for_reload_p (dest,
|
&& reg_overlap_mentioned_for_reload_p (dest,
|
goal))
|
goal))
|
return 0;
|
return 0;
|
}
|
}
|
|
|
else if (goal_mem && MEM_P (dest)
|
else if (goal_mem && MEM_P (dest)
|
&& ! push_operand (dest, GET_MODE (dest)))
|
&& ! push_operand (dest, GET_MODE (dest)))
|
return 0;
|
return 0;
|
else if (need_stable_sp
|
else if (need_stable_sp
|
&& push_operand (dest, GET_MODE (dest)))
|
&& push_operand (dest, GET_MODE (dest)))
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
#ifdef AUTO_INC_DEC
|
#ifdef AUTO_INC_DEC
|
/* If this insn auto-increments or auto-decrements
|
/* If this insn auto-increments or auto-decrements
|
either regno or valueno, return 0 now.
|
either regno or valueno, return 0 now.
|
If GOAL is a memory ref and its address is not constant,
|
If GOAL is a memory ref and its address is not constant,
|
and this insn P increments a register used in GOAL, return 0. */
|
and this insn P increments a register used in GOAL, return 0. */
|
{
|
{
|
rtx link;
|
rtx link;
|
|
|
for (link = REG_NOTES (p); link; link = XEXP (link, 1))
|
for (link = REG_NOTES (p); link; link = XEXP (link, 1))
|
if (REG_NOTE_KIND (link) == REG_INC
|
if (REG_NOTE_KIND (link) == REG_INC
|
&& REG_P (XEXP (link, 0)))
|
&& REG_P (XEXP (link, 0)))
|
{
|
{
|
int incno = REGNO (XEXP (link, 0));
|
int incno = REGNO (XEXP (link, 0));
|
if (incno < regno + nregs && incno >= regno)
|
if (incno < regno + nregs && incno >= regno)
|
return 0;
|
return 0;
|
if (incno < valueno + valuenregs && incno >= valueno)
|
if (incno < valueno + valuenregs && incno >= valueno)
|
return 0;
|
return 0;
|
if (goal_mem_addr_varies
|
if (goal_mem_addr_varies
|
&& reg_overlap_mentioned_for_reload_p (XEXP (link, 0),
|
&& reg_overlap_mentioned_for_reload_p (XEXP (link, 0),
|
goal))
|
goal))
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
#endif
|
#endif
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Find a place where INCED appears in an increment or decrement operator
|
/* Find a place where INCED appears in an increment or decrement operator
|
within X, and return the amount INCED is incremented or decremented by.
|
within X, and return the amount INCED is incremented or decremented by.
|
The value is always positive. */
|
The value is always positive. */
|
|
|
static int
|
static int
|
find_inc_amount (rtx x, rtx inced)
|
find_inc_amount (rtx x, rtx inced)
|
{
|
{
|
enum rtx_code code = GET_CODE (x);
|
enum rtx_code code = GET_CODE (x);
|
const char *fmt;
|
const char *fmt;
|
int i;
|
int i;
|
|
|
if (code == MEM)
|
if (code == MEM)
|
{
|
{
|
rtx addr = XEXP (x, 0);
|
rtx addr = XEXP (x, 0);
|
if ((GET_CODE (addr) == PRE_DEC
|
if ((GET_CODE (addr) == PRE_DEC
|
|| GET_CODE (addr) == POST_DEC
|
|| GET_CODE (addr) == POST_DEC
|
|| GET_CODE (addr) == PRE_INC
|
|| GET_CODE (addr) == PRE_INC
|
|| GET_CODE (addr) == POST_INC)
|
|| GET_CODE (addr) == POST_INC)
|
&& XEXP (addr, 0) == inced)
|
&& XEXP (addr, 0) == inced)
|
return GET_MODE_SIZE (GET_MODE (x));
|
return GET_MODE_SIZE (GET_MODE (x));
|
else if ((GET_CODE (addr) == PRE_MODIFY
|
else if ((GET_CODE (addr) == PRE_MODIFY
|
|| GET_CODE (addr) == POST_MODIFY)
|
|| GET_CODE (addr) == POST_MODIFY)
|
&& GET_CODE (XEXP (addr, 1)) == PLUS
|
&& GET_CODE (XEXP (addr, 1)) == PLUS
|
&& XEXP (addr, 0) == XEXP (XEXP (addr, 1), 0)
|
&& XEXP (addr, 0) == XEXP (XEXP (addr, 1), 0)
|
&& XEXP (addr, 0) == inced
|
&& XEXP (addr, 0) == inced
|
&& GET_CODE (XEXP (XEXP (addr, 1), 1)) == CONST_INT)
|
&& GET_CODE (XEXP (XEXP (addr, 1), 1)) == CONST_INT)
|
{
|
{
|
i = INTVAL (XEXP (XEXP (addr, 1), 1));
|
i = INTVAL (XEXP (XEXP (addr, 1), 1));
|
return i < 0 ? -i : i;
|
return i < 0 ? -i : i;
|
}
|
}
|
}
|
}
|
|
|
fmt = GET_RTX_FORMAT (code);
|
fmt = GET_RTX_FORMAT (code);
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
{
|
{
|
if (fmt[i] == 'e')
|
if (fmt[i] == 'e')
|
{
|
{
|
int tem = find_inc_amount (XEXP (x, i), inced);
|
int tem = find_inc_amount (XEXP (x, i), inced);
|
if (tem != 0)
|
if (tem != 0)
|
return tem;
|
return tem;
|
}
|
}
|
if (fmt[i] == 'E')
|
if (fmt[i] == 'E')
|
{
|
{
|
int j;
|
int j;
|
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
{
|
{
|
int tem = find_inc_amount (XVECEXP (x, i, j), inced);
|
int tem = find_inc_amount (XVECEXP (x, i, j), inced);
|
if (tem != 0)
|
if (tem != 0)
|
return tem;
|
return tem;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Return 1 if registers from REGNO to ENDREGNO are the subjects of a
|
/* Return 1 if registers from REGNO to ENDREGNO are the subjects of a
|
REG_INC note in insn INSN. REGNO must refer to a hard register. */
|
REG_INC note in insn INSN. REGNO must refer to a hard register. */
|
|
|
#ifdef AUTO_INC_DEC
|
#ifdef AUTO_INC_DEC
|
static int
|
static int
|
reg_inc_found_and_valid_p (unsigned int regno, unsigned int endregno,
|
reg_inc_found_and_valid_p (unsigned int regno, unsigned int endregno,
|
rtx insn)
|
rtx insn)
|
{
|
{
|
rtx link;
|
rtx link;
|
|
|
gcc_assert (insn);
|
gcc_assert (insn);
|
|
|
if (! INSN_P (insn))
|
if (! INSN_P (insn))
|
return 0;
|
return 0;
|
|
|
for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
|
for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
|
if (REG_NOTE_KIND (link) == REG_INC)
|
if (REG_NOTE_KIND (link) == REG_INC)
|
{
|
{
|
unsigned int test = (int) REGNO (XEXP (link, 0));
|
unsigned int test = (int) REGNO (XEXP (link, 0));
|
if (test >= regno && test < endregno)
|
if (test >= regno && test < endregno)
|
return 1;
|
return 1;
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
#else
|
#else
|
|
|
#define reg_inc_found_and_valid_p(regno,endregno,insn) 0
|
#define reg_inc_found_and_valid_p(regno,endregno,insn) 0
|
|
|
#endif
|
#endif
|
|
|
/* Return 1 if register REGNO is the subject of a clobber in insn INSN.
|
/* Return 1 if register REGNO is the subject of a clobber in insn INSN.
|
If SETS is 1, also consider SETs. If SETS is 2, enable checking
|
If SETS is 1, also consider SETs. If SETS is 2, enable checking
|
REG_INC. REGNO must refer to a hard register. */
|
REG_INC. REGNO must refer to a hard register. */
|
|
|
int
|
int
|
regno_clobbered_p (unsigned int regno, rtx insn, enum machine_mode mode,
|
regno_clobbered_p (unsigned int regno, rtx insn, enum machine_mode mode,
|
int sets)
|
int sets)
|
{
|
{
|
unsigned int nregs, endregno;
|
unsigned int nregs, endregno;
|
|
|
/* regno must be a hard register. */
|
/* regno must be a hard register. */
|
gcc_assert (regno < FIRST_PSEUDO_REGISTER);
|
gcc_assert (regno < FIRST_PSEUDO_REGISTER);
|
|
|
nregs = hard_regno_nregs[regno][mode];
|
nregs = hard_regno_nregs[regno][mode];
|
endregno = regno + nregs;
|
endregno = regno + nregs;
|
|
|
if ((GET_CODE (PATTERN (insn)) == CLOBBER
|
if ((GET_CODE (PATTERN (insn)) == CLOBBER
|
|| (sets == 1 && GET_CODE (PATTERN (insn)) == SET))
|
|| (sets == 1 && GET_CODE (PATTERN (insn)) == SET))
|
&& REG_P (XEXP (PATTERN (insn), 0)))
|
&& REG_P (XEXP (PATTERN (insn), 0)))
|
{
|
{
|
unsigned int test = REGNO (XEXP (PATTERN (insn), 0));
|
unsigned int test = REGNO (XEXP (PATTERN (insn), 0));
|
|
|
return test >= regno && test < endregno;
|
return test >= regno && test < endregno;
|
}
|
}
|
|
|
if (sets == 2 && reg_inc_found_and_valid_p (regno, endregno, insn))
|
if (sets == 2 && reg_inc_found_and_valid_p (regno, endregno, insn))
|
return 1;
|
return 1;
|
|
|
if (GET_CODE (PATTERN (insn)) == PARALLEL)
|
if (GET_CODE (PATTERN (insn)) == PARALLEL)
|
{
|
{
|
int i = XVECLEN (PATTERN (insn), 0) - 1;
|
int i = XVECLEN (PATTERN (insn), 0) - 1;
|
|
|
for (; i >= 0; i--)
|
for (; i >= 0; i--)
|
{
|
{
|
rtx elt = XVECEXP (PATTERN (insn), 0, i);
|
rtx elt = XVECEXP (PATTERN (insn), 0, i);
|
if ((GET_CODE (elt) == CLOBBER
|
if ((GET_CODE (elt) == CLOBBER
|
|| (sets == 1 && GET_CODE (PATTERN (insn)) == SET))
|
|| (sets == 1 && GET_CODE (PATTERN (insn)) == SET))
|
&& REG_P (XEXP (elt, 0)))
|
&& REG_P (XEXP (elt, 0)))
|
{
|
{
|
unsigned int test = REGNO (XEXP (elt, 0));
|
unsigned int test = REGNO (XEXP (elt, 0));
|
|
|
if (test >= regno && test < endregno)
|
if (test >= regno && test < endregno)
|
return 1;
|
return 1;
|
}
|
}
|
if (sets == 2
|
if (sets == 2
|
&& reg_inc_found_and_valid_p (regno, endregno, elt))
|
&& reg_inc_found_and_valid_p (regno, endregno, elt))
|
return 1;
|
return 1;
|
}
|
}
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Find the low part, with mode MODE, of a hard regno RELOADREG. */
|
/* Find the low part, with mode MODE, of a hard regno RELOADREG. */
|
rtx
|
rtx
|
reload_adjust_reg_for_mode (rtx reloadreg, enum machine_mode mode)
|
reload_adjust_reg_for_mode (rtx reloadreg, enum machine_mode mode)
|
{
|
{
|
int regno;
|
int regno;
|
|
|
if (GET_MODE (reloadreg) == mode)
|
if (GET_MODE (reloadreg) == mode)
|
return reloadreg;
|
return reloadreg;
|
|
|
regno = REGNO (reloadreg);
|
regno = REGNO (reloadreg);
|
|
|
if (WORDS_BIG_ENDIAN)
|
if (WORDS_BIG_ENDIAN)
|
regno += (int) hard_regno_nregs[regno][GET_MODE (reloadreg)]
|
regno += (int) hard_regno_nregs[regno][GET_MODE (reloadreg)]
|
- (int) hard_regno_nregs[regno][mode];
|
- (int) hard_regno_nregs[regno][mode];
|
|
|
return gen_rtx_REG (mode, regno);
|
return gen_rtx_REG (mode, regno);
|
}
|
}
|
|
|
static const char *const reload_when_needed_name[] =
|
static const char *const reload_when_needed_name[] =
|
{
|
{
|
"RELOAD_FOR_INPUT",
|
"RELOAD_FOR_INPUT",
|
"RELOAD_FOR_OUTPUT",
|
"RELOAD_FOR_OUTPUT",
|
"RELOAD_FOR_INSN",
|
"RELOAD_FOR_INSN",
|
"RELOAD_FOR_INPUT_ADDRESS",
|
"RELOAD_FOR_INPUT_ADDRESS",
|
"RELOAD_FOR_INPADDR_ADDRESS",
|
"RELOAD_FOR_INPADDR_ADDRESS",
|
"RELOAD_FOR_OUTPUT_ADDRESS",
|
"RELOAD_FOR_OUTPUT_ADDRESS",
|
"RELOAD_FOR_OUTADDR_ADDRESS",
|
"RELOAD_FOR_OUTADDR_ADDRESS",
|
"RELOAD_FOR_OPERAND_ADDRESS",
|
"RELOAD_FOR_OPERAND_ADDRESS",
|
"RELOAD_FOR_OPADDR_ADDR",
|
"RELOAD_FOR_OPADDR_ADDR",
|
"RELOAD_OTHER",
|
"RELOAD_OTHER",
|
"RELOAD_FOR_OTHER_ADDRESS"
|
"RELOAD_FOR_OTHER_ADDRESS"
|
};
|
};
|
|
|
/* These functions are used to print the variables set by 'find_reloads' */
|
/* These functions are used to print the variables set by 'find_reloads' */
|
|
|
void
|
void
|
debug_reload_to_stream (FILE *f)
|
debug_reload_to_stream (FILE *f)
|
{
|
{
|
int r;
|
int r;
|
const char *prefix;
|
const char *prefix;
|
|
|
if (! f)
|
if (! f)
|
f = stderr;
|
f = stderr;
|
for (r = 0; r < n_reloads; r++)
|
for (r = 0; r < n_reloads; r++)
|
{
|
{
|
fprintf (f, "Reload %d: ", r);
|
fprintf (f, "Reload %d: ", r);
|
|
|
if (rld[r].in != 0)
|
if (rld[r].in != 0)
|
{
|
{
|
fprintf (f, "reload_in (%s) = ",
|
fprintf (f, "reload_in (%s) = ",
|
GET_MODE_NAME (rld[r].inmode));
|
GET_MODE_NAME (rld[r].inmode));
|
print_inline_rtx (f, rld[r].in, 24);
|
print_inline_rtx (f, rld[r].in, 24);
|
fprintf (f, "\n\t");
|
fprintf (f, "\n\t");
|
}
|
}
|
|
|
if (rld[r].out != 0)
|
if (rld[r].out != 0)
|
{
|
{
|
fprintf (f, "reload_out (%s) = ",
|
fprintf (f, "reload_out (%s) = ",
|
GET_MODE_NAME (rld[r].outmode));
|
GET_MODE_NAME (rld[r].outmode));
|
print_inline_rtx (f, rld[r].out, 24);
|
print_inline_rtx (f, rld[r].out, 24);
|
fprintf (f, "\n\t");
|
fprintf (f, "\n\t");
|
}
|
}
|
|
|
fprintf (f, "%s, ", reg_class_names[(int) rld[r].class]);
|
fprintf (f, "%s, ", reg_class_names[(int) rld[r].class]);
|
|
|
fprintf (f, "%s (opnum = %d)",
|
fprintf (f, "%s (opnum = %d)",
|
reload_when_needed_name[(int) rld[r].when_needed],
|
reload_when_needed_name[(int) rld[r].when_needed],
|
rld[r].opnum);
|
rld[r].opnum);
|
|
|
if (rld[r].optional)
|
if (rld[r].optional)
|
fprintf (f, ", optional");
|
fprintf (f, ", optional");
|
|
|
if (rld[r].nongroup)
|
if (rld[r].nongroup)
|
fprintf (f, ", nongroup");
|
fprintf (f, ", nongroup");
|
|
|
if (rld[r].inc != 0)
|
if (rld[r].inc != 0)
|
fprintf (f, ", inc by %d", rld[r].inc);
|
fprintf (f, ", inc by %d", rld[r].inc);
|
|
|
if (rld[r].nocombine)
|
if (rld[r].nocombine)
|
fprintf (f, ", can't combine");
|
fprintf (f, ", can't combine");
|
|
|
if (rld[r].secondary_p)
|
if (rld[r].secondary_p)
|
fprintf (f, ", secondary_reload_p");
|
fprintf (f, ", secondary_reload_p");
|
|
|
if (rld[r].in_reg != 0)
|
if (rld[r].in_reg != 0)
|
{
|
{
|
fprintf (f, "\n\treload_in_reg: ");
|
fprintf (f, "\n\treload_in_reg: ");
|
print_inline_rtx (f, rld[r].in_reg, 24);
|
print_inline_rtx (f, rld[r].in_reg, 24);
|
}
|
}
|
|
|
if (rld[r].out_reg != 0)
|
if (rld[r].out_reg != 0)
|
{
|
{
|
fprintf (f, "\n\treload_out_reg: ");
|
fprintf (f, "\n\treload_out_reg: ");
|
print_inline_rtx (f, rld[r].out_reg, 24);
|
print_inline_rtx (f, rld[r].out_reg, 24);
|
}
|
}
|
|
|
if (rld[r].reg_rtx != 0)
|
if (rld[r].reg_rtx != 0)
|
{
|
{
|
fprintf (f, "\n\treload_reg_rtx: ");
|
fprintf (f, "\n\treload_reg_rtx: ");
|
print_inline_rtx (f, rld[r].reg_rtx, 24);
|
print_inline_rtx (f, rld[r].reg_rtx, 24);
|
}
|
}
|
|
|
prefix = "\n\t";
|
prefix = "\n\t";
|
if (rld[r].secondary_in_reload != -1)
|
if (rld[r].secondary_in_reload != -1)
|
{
|
{
|
fprintf (f, "%ssecondary_in_reload = %d",
|
fprintf (f, "%ssecondary_in_reload = %d",
|
prefix, rld[r].secondary_in_reload);
|
prefix, rld[r].secondary_in_reload);
|
prefix = ", ";
|
prefix = ", ";
|
}
|
}
|
|
|
if (rld[r].secondary_out_reload != -1)
|
if (rld[r].secondary_out_reload != -1)
|
fprintf (f, "%ssecondary_out_reload = %d\n",
|
fprintf (f, "%ssecondary_out_reload = %d\n",
|
prefix, rld[r].secondary_out_reload);
|
prefix, rld[r].secondary_out_reload);
|
|
|
prefix = "\n\t";
|
prefix = "\n\t";
|
if (rld[r].secondary_in_icode != CODE_FOR_nothing)
|
if (rld[r].secondary_in_icode != CODE_FOR_nothing)
|
{
|
{
|
fprintf (f, "%ssecondary_in_icode = %s", prefix,
|
fprintf (f, "%ssecondary_in_icode = %s", prefix,
|
insn_data[rld[r].secondary_in_icode].name);
|
insn_data[rld[r].secondary_in_icode].name);
|
prefix = ", ";
|
prefix = ", ";
|
}
|
}
|
|
|
if (rld[r].secondary_out_icode != CODE_FOR_nothing)
|
if (rld[r].secondary_out_icode != CODE_FOR_nothing)
|
fprintf (f, "%ssecondary_out_icode = %s", prefix,
|
fprintf (f, "%ssecondary_out_icode = %s", prefix,
|
insn_data[rld[r].secondary_out_icode].name);
|
insn_data[rld[r].secondary_out_icode].name);
|
|
|
fprintf (f, "\n");
|
fprintf (f, "\n");
|
}
|
}
|
}
|
}
|
|
|
void
|
void
|
debug_reload (void)
|
debug_reload (void)
|
{
|
{
|
debug_reload_to_stream (stderr);
|
debug_reload_to_stream (stderr);
|
}
|
}
|
|
|
