/* Subroutines used by or related to instruction recognition.
|
/* Subroutines used by or related to instruction recognition.
|
Copyright (C) 1987, 1988, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998
|
Copyright (C) 1987, 1988, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998
|
1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007
|
1999, 2000, 2001, 2002, 2003, 2004, 2005, 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/>. */
|
|
|
|
|
#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 "insn-attr.h"
|
#include "insn-attr.h"
|
#include "hard-reg-set.h"
|
#include "hard-reg-set.h"
|
#include "recog.h"
|
#include "recog.h"
|
#include "regs.h"
|
#include "regs.h"
|
#include "addresses.h"
|
#include "addresses.h"
|
#include "expr.h"
|
#include "expr.h"
|
#include "function.h"
|
#include "function.h"
|
#include "flags.h"
|
#include "flags.h"
|
#include "real.h"
|
#include "real.h"
|
#include "toplev.h"
|
#include "toplev.h"
|
#include "basic-block.h"
|
#include "basic-block.h"
|
#include "output.h"
|
#include "output.h"
|
#include "reload.h"
|
#include "reload.h"
|
#include "timevar.h"
|
#include "timevar.h"
|
#include "tree-pass.h"
|
#include "tree-pass.h"
|
|
|
#ifndef STACK_PUSH_CODE
|
#ifndef STACK_PUSH_CODE
|
#ifdef STACK_GROWS_DOWNWARD
|
#ifdef STACK_GROWS_DOWNWARD
|
#define STACK_PUSH_CODE PRE_DEC
|
#define STACK_PUSH_CODE PRE_DEC
|
#else
|
#else
|
#define STACK_PUSH_CODE PRE_INC
|
#define STACK_PUSH_CODE PRE_INC
|
#endif
|
#endif
|
#endif
|
#endif
|
|
|
#ifndef STACK_POP_CODE
|
#ifndef STACK_POP_CODE
|
#ifdef STACK_GROWS_DOWNWARD
|
#ifdef STACK_GROWS_DOWNWARD
|
#define STACK_POP_CODE POST_INC
|
#define STACK_POP_CODE POST_INC
|
#else
|
#else
|
#define STACK_POP_CODE POST_DEC
|
#define STACK_POP_CODE POST_DEC
|
#endif
|
#endif
|
#endif
|
#endif
|
|
|
static void validate_replace_rtx_1 (rtx *, rtx, rtx, rtx);
|
static void validate_replace_rtx_1 (rtx *, rtx, rtx, rtx);
|
static rtx *find_single_use_1 (rtx, rtx *);
|
static rtx *find_single_use_1 (rtx, rtx *);
|
static void validate_replace_src_1 (rtx *, void *);
|
static void validate_replace_src_1 (rtx *, void *);
|
static rtx split_insn (rtx);
|
static rtx split_insn (rtx);
|
|
|
/* Nonzero means allow operands to be volatile.
|
/* Nonzero means allow operands to be volatile.
|
This should be 0 if you are generating rtl, such as if you are calling
|
This should be 0 if you are generating rtl, such as if you are calling
|
the functions in optabs.c and expmed.c (most of the time).
|
the functions in optabs.c and expmed.c (most of the time).
|
This should be 1 if all valid insns need to be recognized,
|
This should be 1 if all valid insns need to be recognized,
|
such as in regclass.c and final.c and reload.c.
|
such as in regclass.c and final.c and reload.c.
|
|
|
init_recog and init_recog_no_volatile are responsible for setting this. */
|
init_recog and init_recog_no_volatile are responsible for setting this. */
|
|
|
int volatile_ok;
|
int volatile_ok;
|
|
|
struct recog_data recog_data;
|
struct recog_data recog_data;
|
|
|
/* Contains a vector of operand_alternative structures for every operand.
|
/* Contains a vector of operand_alternative structures for every operand.
|
Set up by preprocess_constraints. */
|
Set up by preprocess_constraints. */
|
struct operand_alternative recog_op_alt[MAX_RECOG_OPERANDS][MAX_RECOG_ALTERNATIVES];
|
struct operand_alternative recog_op_alt[MAX_RECOG_OPERANDS][MAX_RECOG_ALTERNATIVES];
|
|
|
/* On return from `constrain_operands', indicate which alternative
|
/* On return from `constrain_operands', indicate which alternative
|
was satisfied. */
|
was satisfied. */
|
|
|
int which_alternative;
|
int which_alternative;
|
|
|
/* Nonzero after end of reload pass.
|
/* Nonzero after end of reload pass.
|
Set to 1 or 0 by toplev.c.
|
Set to 1 or 0 by toplev.c.
|
Controls the significance of (SUBREG (MEM)). */
|
Controls the significance of (SUBREG (MEM)). */
|
|
|
int reload_completed;
|
int reload_completed;
|
|
|
/* Nonzero after thread_prologue_and_epilogue_insns has run. */
|
/* Nonzero after thread_prologue_and_epilogue_insns has run. */
|
int epilogue_completed;
|
int epilogue_completed;
|
|
|
/* Initialize data used by the function `recog'.
|
/* Initialize data used by the function `recog'.
|
This must be called once in the compilation of a function
|
This must be called once in the compilation of a function
|
before any insn recognition may be done in the function. */
|
before any insn recognition may be done in the function. */
|
|
|
void
|
void
|
init_recog_no_volatile (void)
|
init_recog_no_volatile (void)
|
{
|
{
|
volatile_ok = 0;
|
volatile_ok = 0;
|
}
|
}
|
|
|
void
|
void
|
init_recog (void)
|
init_recog (void)
|
{
|
{
|
volatile_ok = 1;
|
volatile_ok = 1;
|
}
|
}
|
|
|
|
|
/* Check that X is an insn-body for an `asm' with operands
|
/* Check that X is an insn-body for an `asm' with operands
|
and that the operands mentioned in it are legitimate. */
|
and that the operands mentioned in it are legitimate. */
|
|
|
int
|
int
|
check_asm_operands (rtx x)
|
check_asm_operands (rtx x)
|
{
|
{
|
int noperands;
|
int noperands;
|
rtx *operands;
|
rtx *operands;
|
const char **constraints;
|
const char **constraints;
|
int i;
|
int i;
|
|
|
/* Post-reload, be more strict with things. */
|
/* Post-reload, be more strict with things. */
|
if (reload_completed)
|
if (reload_completed)
|
{
|
{
|
/* ??? Doh! We've not got the wrapping insn. Cook one up. */
|
/* ??? Doh! We've not got the wrapping insn. Cook one up. */
|
extract_insn (make_insn_raw (x));
|
extract_insn (make_insn_raw (x));
|
constrain_operands (1);
|
constrain_operands (1);
|
return which_alternative >= 0;
|
return which_alternative >= 0;
|
}
|
}
|
|
|
noperands = asm_noperands (x);
|
noperands = asm_noperands (x);
|
if (noperands < 0)
|
if (noperands < 0)
|
return 0;
|
return 0;
|
if (noperands == 0)
|
if (noperands == 0)
|
return 1;
|
return 1;
|
|
|
operands = alloca (noperands * sizeof (rtx));
|
operands = alloca (noperands * sizeof (rtx));
|
constraints = alloca (noperands * sizeof (char *));
|
constraints = alloca (noperands * sizeof (char *));
|
|
|
decode_asm_operands (x, operands, NULL, constraints, NULL);
|
decode_asm_operands (x, operands, NULL, constraints, NULL);
|
|
|
for (i = 0; i < noperands; i++)
|
for (i = 0; i < noperands; i++)
|
{
|
{
|
const char *c = constraints[i];
|
const char *c = constraints[i];
|
if (c[0] == '%')
|
if (c[0] == '%')
|
c++;
|
c++;
|
if (ISDIGIT ((unsigned char) c[0]) && c[1] == '\0')
|
if (ISDIGIT ((unsigned char) c[0]) && c[1] == '\0')
|
c = constraints[c[0] - '0'];
|
c = constraints[c[0] - '0'];
|
|
|
if (! asm_operand_ok (operands[i], c))
|
if (! asm_operand_ok (operands[i], c))
|
return 0;
|
return 0;
|
}
|
}
|
|
|
return 1;
|
return 1;
|
}
|
}
|
|
|
/* Static data for the next two routines. */
|
/* Static data for the next two routines. */
|
|
|
typedef struct change_t
|
typedef struct change_t
|
{
|
{
|
rtx object;
|
rtx object;
|
int old_code;
|
int old_code;
|
rtx *loc;
|
rtx *loc;
|
rtx old;
|
rtx old;
|
} change_t;
|
} change_t;
|
|
|
static change_t *changes;
|
static change_t *changes;
|
static int changes_allocated;
|
static int changes_allocated;
|
|
|
static int num_changes = 0;
|
static int num_changes = 0;
|
|
|
/* Validate a proposed change to OBJECT. LOC is the location in the rtl
|
/* Validate a proposed change to OBJECT. LOC is the location in the rtl
|
at which NEW will be placed. If OBJECT is zero, no validation is done,
|
at which NEW will be placed. If OBJECT is zero, no validation is done,
|
the change is simply made.
|
the change is simply made.
|
|
|
Two types of objects are supported: If OBJECT is a MEM, memory_address_p
|
Two types of objects are supported: If OBJECT is a MEM, memory_address_p
|
will be called with the address and mode as parameters. If OBJECT is
|
will be called with the address and mode as parameters. If OBJECT is
|
an INSN, CALL_INSN, or JUMP_INSN, the insn will be re-recognized with
|
an INSN, CALL_INSN, or JUMP_INSN, the insn will be re-recognized with
|
the change in place.
|
the change in place.
|
|
|
IN_GROUP is nonzero if this is part of a group of changes that must be
|
IN_GROUP is nonzero if this is part of a group of changes that must be
|
performed as a group. In that case, the changes will be stored. The
|
performed as a group. In that case, the changes will be stored. The
|
function `apply_change_group' will validate and apply the changes.
|
function `apply_change_group' will validate and apply the changes.
|
|
|
If IN_GROUP is zero, this is a single change. Try to recognize the insn
|
If IN_GROUP is zero, this is a single change. Try to recognize the insn
|
or validate the memory reference with the change applied. If the result
|
or validate the memory reference with the change applied. If the result
|
is not valid for the machine, suppress the change and return zero.
|
is not valid for the machine, suppress the change and return zero.
|
Otherwise, perform the change and return 1. */
|
Otherwise, perform the change and return 1. */
|
|
|
int
|
int
|
validate_change (rtx object, rtx *loc, rtx new, int in_group)
|
validate_change (rtx object, rtx *loc, rtx new, int in_group)
|
{
|
{
|
rtx old = *loc;
|
rtx old = *loc;
|
|
|
if (old == new || rtx_equal_p (old, new))
|
if (old == new || rtx_equal_p (old, new))
|
return 1;
|
return 1;
|
|
|
gcc_assert (in_group != 0 || num_changes == 0);
|
gcc_assert (in_group != 0 || num_changes == 0);
|
|
|
*loc = new;
|
*loc = new;
|
|
|
/* Save the information describing this change. */
|
/* Save the information describing this change. */
|
if (num_changes >= changes_allocated)
|
if (num_changes >= changes_allocated)
|
{
|
{
|
if (changes_allocated == 0)
|
if (changes_allocated == 0)
|
/* This value allows for repeated substitutions inside complex
|
/* This value allows for repeated substitutions inside complex
|
indexed addresses, or changes in up to 5 insns. */
|
indexed addresses, or changes in up to 5 insns. */
|
changes_allocated = MAX_RECOG_OPERANDS * 5;
|
changes_allocated = MAX_RECOG_OPERANDS * 5;
|
else
|
else
|
changes_allocated *= 2;
|
changes_allocated *= 2;
|
|
|
changes = xrealloc (changes, sizeof (change_t) * changes_allocated);
|
changes = xrealloc (changes, sizeof (change_t) * changes_allocated);
|
}
|
}
|
|
|
changes[num_changes].object = object;
|
changes[num_changes].object = object;
|
changes[num_changes].loc = loc;
|
changes[num_changes].loc = loc;
|
changes[num_changes].old = old;
|
changes[num_changes].old = old;
|
|
|
if (object && !MEM_P (object))
|
if (object && !MEM_P (object))
|
{
|
{
|
/* Set INSN_CODE to force rerecognition of insn. Save old code in
|
/* Set INSN_CODE to force rerecognition of insn. Save old code in
|
case invalid. */
|
case invalid. */
|
changes[num_changes].old_code = INSN_CODE (object);
|
changes[num_changes].old_code = INSN_CODE (object);
|
INSN_CODE (object) = -1;
|
INSN_CODE (object) = -1;
|
}
|
}
|
|
|
num_changes++;
|
num_changes++;
|
|
|
/* If we are making a group of changes, return 1. Otherwise, validate the
|
/* If we are making a group of changes, return 1. Otherwise, validate the
|
change group we made. */
|
change group we made. */
|
|
|
if (in_group)
|
if (in_group)
|
return 1;
|
return 1;
|
else
|
else
|
return apply_change_group ();
|
return apply_change_group ();
|
}
|
}
|
|
|
|
|
/* This subroutine of apply_change_group verifies whether the changes to INSN
|
/* This subroutine of apply_change_group verifies whether the changes to INSN
|
were valid; i.e. whether INSN can still be recognized. */
|
were valid; i.e. whether INSN can still be recognized. */
|
|
|
int
|
int
|
insn_invalid_p (rtx insn)
|
insn_invalid_p (rtx insn)
|
{
|
{
|
rtx pat = PATTERN (insn);
|
rtx pat = PATTERN (insn);
|
int num_clobbers = 0;
|
int num_clobbers = 0;
|
/* If we are before reload and the pattern is a SET, see if we can add
|
/* If we are before reload and the pattern is a SET, see if we can add
|
clobbers. */
|
clobbers. */
|
int icode = recog (pat, insn,
|
int icode = recog (pat, insn,
|
(GET_CODE (pat) == SET
|
(GET_CODE (pat) == SET
|
&& ! reload_completed && ! reload_in_progress)
|
&& ! reload_completed && ! reload_in_progress)
|
? &num_clobbers : 0);
|
? &num_clobbers : 0);
|
int is_asm = icode < 0 && asm_noperands (PATTERN (insn)) >= 0;
|
int is_asm = icode < 0 && asm_noperands (PATTERN (insn)) >= 0;
|
|
|
|
|
/* If this is an asm and the operand aren't legal, then fail. Likewise if
|
/* If this is an asm and the operand aren't legal, then fail. Likewise if
|
this is not an asm and the insn wasn't recognized. */
|
this is not an asm and the insn wasn't recognized. */
|
if ((is_asm && ! check_asm_operands (PATTERN (insn)))
|
if ((is_asm && ! check_asm_operands (PATTERN (insn)))
|
|| (!is_asm && icode < 0))
|
|| (!is_asm && icode < 0))
|
return 1;
|
return 1;
|
|
|
/* If we have to add CLOBBERs, fail if we have to add ones that reference
|
/* If we have to add CLOBBERs, fail if we have to add ones that reference
|
hard registers since our callers can't know if they are live or not.
|
hard registers since our callers can't know if they are live or not.
|
Otherwise, add them. */
|
Otherwise, add them. */
|
if (num_clobbers > 0)
|
if (num_clobbers > 0)
|
{
|
{
|
rtx newpat;
|
rtx newpat;
|
|
|
if (added_clobbers_hard_reg_p (icode))
|
if (added_clobbers_hard_reg_p (icode))
|
return 1;
|
return 1;
|
|
|
newpat = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (num_clobbers + 1));
|
newpat = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (num_clobbers + 1));
|
XVECEXP (newpat, 0, 0) = pat;
|
XVECEXP (newpat, 0, 0) = pat;
|
add_clobbers (newpat, icode);
|
add_clobbers (newpat, icode);
|
PATTERN (insn) = pat = newpat;
|
PATTERN (insn) = pat = newpat;
|
}
|
}
|
|
|
/* After reload, verify that all constraints are satisfied. */
|
/* After reload, verify that all constraints are satisfied. */
|
if (reload_completed)
|
if (reload_completed)
|
{
|
{
|
extract_insn (insn);
|
extract_insn (insn);
|
|
|
if (! constrain_operands (1))
|
if (! constrain_operands (1))
|
return 1;
|
return 1;
|
}
|
}
|
|
|
INSN_CODE (insn) = icode;
|
INSN_CODE (insn) = icode;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Return number of changes made and not validated yet. */
|
/* Return number of changes made and not validated yet. */
|
int
|
int
|
num_changes_pending (void)
|
num_changes_pending (void)
|
{
|
{
|
return num_changes;
|
return num_changes;
|
}
|
}
|
|
|
/* Tentatively apply the changes numbered NUM and up.
|
/* Tentatively apply the changes numbered NUM and up.
|
Return 1 if all changes are valid, zero otherwise. */
|
Return 1 if all changes are valid, zero otherwise. */
|
|
|
int
|
int
|
verify_changes (int num)
|
verify_changes (int num)
|
{
|
{
|
int i;
|
int i;
|
rtx last_validated = NULL_RTX;
|
rtx last_validated = NULL_RTX;
|
|
|
/* The changes have been applied and all INSN_CODEs have been reset to force
|
/* The changes have been applied and all INSN_CODEs have been reset to force
|
rerecognition.
|
rerecognition.
|
|
|
The changes are valid if we aren't given an object, or if we are
|
The changes are valid if we aren't given an object, or if we are
|
given a MEM and it still is a valid address, or if this is in insn
|
given a MEM and it still is a valid address, or if this is in insn
|
and it is recognized. In the latter case, if reload has completed,
|
and it is recognized. In the latter case, if reload has completed,
|
we also require that the operands meet the constraints for
|
we also require that the operands meet the constraints for
|
the insn. */
|
the insn. */
|
|
|
for (i = num; i < num_changes; i++)
|
for (i = num; i < num_changes; i++)
|
{
|
{
|
rtx object = changes[i].object;
|
rtx object = changes[i].object;
|
|
|
/* If there is no object to test or if it is the same as the one we
|
/* If there is no object to test or if it is the same as the one we
|
already tested, ignore it. */
|
already tested, ignore it. */
|
if (object == 0 || object == last_validated)
|
if (object == 0 || object == last_validated)
|
continue;
|
continue;
|
|
|
if (MEM_P (object))
|
if (MEM_P (object))
|
{
|
{
|
if (! memory_address_p (GET_MODE (object), XEXP (object, 0)))
|
if (! memory_address_p (GET_MODE (object), XEXP (object, 0)))
|
break;
|
break;
|
}
|
}
|
else if (insn_invalid_p (object))
|
else if (insn_invalid_p (object))
|
{
|
{
|
rtx pat = PATTERN (object);
|
rtx pat = PATTERN (object);
|
|
|
/* Perhaps we couldn't recognize the insn because there were
|
/* Perhaps we couldn't recognize the insn because there were
|
extra CLOBBERs at the end. If so, try to re-recognize
|
extra CLOBBERs at the end. If so, try to re-recognize
|
without the last CLOBBER (later iterations will cause each of
|
without the last CLOBBER (later iterations will cause each of
|
them to be eliminated, in turn). But don't do this if we
|
them to be eliminated, in turn). But don't do this if we
|
have an ASM_OPERAND. */
|
have an ASM_OPERAND. */
|
if (GET_CODE (pat) == PARALLEL
|
if (GET_CODE (pat) == PARALLEL
|
&& GET_CODE (XVECEXP (pat, 0, XVECLEN (pat, 0) - 1)) == CLOBBER
|
&& GET_CODE (XVECEXP (pat, 0, XVECLEN (pat, 0) - 1)) == CLOBBER
|
&& asm_noperands (PATTERN (object)) < 0)
|
&& asm_noperands (PATTERN (object)) < 0)
|
{
|
{
|
rtx newpat;
|
rtx newpat;
|
|
|
if (XVECLEN (pat, 0) == 2)
|
if (XVECLEN (pat, 0) == 2)
|
newpat = XVECEXP (pat, 0, 0);
|
newpat = XVECEXP (pat, 0, 0);
|
else
|
else
|
{
|
{
|
int j;
|
int j;
|
|
|
newpat
|
newpat
|
= gen_rtx_PARALLEL (VOIDmode,
|
= gen_rtx_PARALLEL (VOIDmode,
|
rtvec_alloc (XVECLEN (pat, 0) - 1));
|
rtvec_alloc (XVECLEN (pat, 0) - 1));
|
for (j = 0; j < XVECLEN (newpat, 0); j++)
|
for (j = 0; j < XVECLEN (newpat, 0); j++)
|
XVECEXP (newpat, 0, j) = XVECEXP (pat, 0, j);
|
XVECEXP (newpat, 0, j) = XVECEXP (pat, 0, j);
|
}
|
}
|
|
|
/* Add a new change to this group to replace the pattern
|
/* Add a new change to this group to replace the pattern
|
with this new pattern. Then consider this change
|
with this new pattern. Then consider this change
|
as having succeeded. The change we added will
|
as having succeeded. The change we added will
|
cause the entire call to fail if things remain invalid.
|
cause the entire call to fail if things remain invalid.
|
|
|
Note that this can lose if a later change than the one
|
Note that this can lose if a later change than the one
|
we are processing specified &XVECEXP (PATTERN (object), 0, X)
|
we are processing specified &XVECEXP (PATTERN (object), 0, X)
|
but this shouldn't occur. */
|
but this shouldn't occur. */
|
|
|
validate_change (object, &PATTERN (object), newpat, 1);
|
validate_change (object, &PATTERN (object), newpat, 1);
|
continue;
|
continue;
|
}
|
}
|
else if (GET_CODE (pat) == USE || GET_CODE (pat) == CLOBBER)
|
else if (GET_CODE (pat) == USE || GET_CODE (pat) == CLOBBER)
|
/* If this insn is a CLOBBER or USE, it is always valid, but is
|
/* If this insn is a CLOBBER or USE, it is always valid, but is
|
never recognized. */
|
never recognized. */
|
continue;
|
continue;
|
else
|
else
|
break;
|
break;
|
}
|
}
|
last_validated = object;
|
last_validated = object;
|
}
|
}
|
|
|
return (i == num_changes);
|
return (i == num_changes);
|
}
|
}
|
|
|
/* A group of changes has previously been issued with validate_change and
|
/* A group of changes has previously been issued with validate_change and
|
verified with verify_changes. Update the BB_DIRTY flags of the affected
|
verified with verify_changes. Update the BB_DIRTY flags of the affected
|
blocks, and clear num_changes. */
|
blocks, and clear num_changes. */
|
|
|
void
|
void
|
confirm_change_group (void)
|
confirm_change_group (void)
|
{
|
{
|
int i;
|
int i;
|
basic_block bb;
|
basic_block bb;
|
|
|
for (i = 0; i < num_changes; i++)
|
for (i = 0; i < num_changes; i++)
|
if (changes[i].object
|
if (changes[i].object
|
&& INSN_P (changes[i].object)
|
&& INSN_P (changes[i].object)
|
&& (bb = BLOCK_FOR_INSN (changes[i].object)))
|
&& (bb = BLOCK_FOR_INSN (changes[i].object)))
|
bb->flags |= BB_DIRTY;
|
bb->flags |= BB_DIRTY;
|
|
|
num_changes = 0;
|
num_changes = 0;
|
}
|
}
|
|
|
/* Apply a group of changes previously issued with `validate_change'.
|
/* Apply a group of changes previously issued with `validate_change'.
|
If all changes are valid, call confirm_change_group and return 1,
|
If all changes are valid, call confirm_change_group and return 1,
|
otherwise, call cancel_changes and return 0. */
|
otherwise, call cancel_changes and return 0. */
|
|
|
int
|
int
|
apply_change_group (void)
|
apply_change_group (void)
|
{
|
{
|
if (verify_changes (0))
|
if (verify_changes (0))
|
{
|
{
|
confirm_change_group ();
|
confirm_change_group ();
|
return 1;
|
return 1;
|
}
|
}
|
else
|
else
|
{
|
{
|
cancel_changes (0);
|
cancel_changes (0);
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Return the number of changes so far in the current group. */
|
/* Return the number of changes so far in the current group. */
|
|
|
int
|
int
|
num_validated_changes (void)
|
num_validated_changes (void)
|
{
|
{
|
return num_changes;
|
return num_changes;
|
}
|
}
|
|
|
/* Retract the changes numbered NUM and up. */
|
/* Retract the changes numbered NUM and up. */
|
|
|
void
|
void
|
cancel_changes (int num)
|
cancel_changes (int num)
|
{
|
{
|
int i;
|
int i;
|
|
|
/* Back out all the changes. Do this in the opposite order in which
|
/* Back out all the changes. Do this in the opposite order in which
|
they were made. */
|
they were made. */
|
for (i = num_changes - 1; i >= num; i--)
|
for (i = num_changes - 1; i >= num; i--)
|
{
|
{
|
*changes[i].loc = changes[i].old;
|
*changes[i].loc = changes[i].old;
|
if (changes[i].object && !MEM_P (changes[i].object))
|
if (changes[i].object && !MEM_P (changes[i].object))
|
INSN_CODE (changes[i].object) = changes[i].old_code;
|
INSN_CODE (changes[i].object) = changes[i].old_code;
|
}
|
}
|
num_changes = num;
|
num_changes = num;
|
}
|
}
|
|
|
/* Replace every occurrence of FROM in X with TO. Mark each change with
|
/* Replace every occurrence of FROM in X with TO. Mark each change with
|
validate_change passing OBJECT. */
|
validate_change passing OBJECT. */
|
|
|
static void
|
static void
|
validate_replace_rtx_1 (rtx *loc, rtx from, rtx to, rtx object)
|
validate_replace_rtx_1 (rtx *loc, rtx from, rtx to, rtx object)
|
{
|
{
|
int i, j;
|
int i, j;
|
const char *fmt;
|
const char *fmt;
|
rtx x = *loc;
|
rtx x = *loc;
|
enum rtx_code code;
|
enum rtx_code code;
|
enum machine_mode op0_mode = VOIDmode;
|
enum machine_mode op0_mode = VOIDmode;
|
int prev_changes = num_changes;
|
int prev_changes = num_changes;
|
rtx new;
|
rtx new;
|
|
|
if (!x)
|
if (!x)
|
return;
|
return;
|
|
|
code = GET_CODE (x);
|
code = GET_CODE (x);
|
fmt = GET_RTX_FORMAT (code);
|
fmt = GET_RTX_FORMAT (code);
|
if (fmt[0] == 'e')
|
if (fmt[0] == 'e')
|
op0_mode = GET_MODE (XEXP (x, 0));
|
op0_mode = GET_MODE (XEXP (x, 0));
|
|
|
/* X matches FROM if it is the same rtx or they are both referring to the
|
/* X matches FROM if it is the same rtx or they are both referring to the
|
same register in the same mode. Avoid calling rtx_equal_p unless the
|
same register in the same mode. Avoid calling rtx_equal_p unless the
|
operands look similar. */
|
operands look similar. */
|
|
|
if (x == from
|
if (x == from
|
|| (REG_P (x) && REG_P (from)
|
|| (REG_P (x) && REG_P (from)
|
&& GET_MODE (x) == GET_MODE (from)
|
&& GET_MODE (x) == GET_MODE (from)
|
&& REGNO (x) == REGNO (from))
|
&& REGNO (x) == REGNO (from))
|
|| (GET_CODE (x) == GET_CODE (from) && GET_MODE (x) == GET_MODE (from)
|
|| (GET_CODE (x) == GET_CODE (from) && GET_MODE (x) == GET_MODE (from)
|
&& rtx_equal_p (x, from)))
|
&& rtx_equal_p (x, from)))
|
{
|
{
|
validate_change (object, loc, to, 1);
|
validate_change (object, loc, to, 1);
|
return;
|
return;
|
}
|
}
|
|
|
/* Call ourself recursively to perform the replacements.
|
/* Call ourself recursively to perform the replacements.
|
We must not replace inside already replaced expression, otherwise we
|
We must not replace inside already replaced expression, otherwise we
|
get infinite recursion for replacements like (reg X)->(subreg (reg X))
|
get infinite recursion for replacements like (reg X)->(subreg (reg X))
|
done by regmove, so we must special case shared ASM_OPERANDS. */
|
done by regmove, so we must special case shared ASM_OPERANDS. */
|
|
|
if (GET_CODE (x) == PARALLEL)
|
if (GET_CODE (x) == PARALLEL)
|
{
|
{
|
for (j = XVECLEN (x, 0) - 1; j >= 0; j--)
|
for (j = XVECLEN (x, 0) - 1; j >= 0; j--)
|
{
|
{
|
if (j && GET_CODE (XVECEXP (x, 0, j)) == SET
|
if (j && GET_CODE (XVECEXP (x, 0, j)) == SET
|
&& GET_CODE (SET_SRC (XVECEXP (x, 0, j))) == ASM_OPERANDS)
|
&& GET_CODE (SET_SRC (XVECEXP (x, 0, j))) == ASM_OPERANDS)
|
{
|
{
|
/* Verify that operands are really shared. */
|
/* Verify that operands are really shared. */
|
gcc_assert (ASM_OPERANDS_INPUT_VEC (SET_SRC (XVECEXP (x, 0, 0)))
|
gcc_assert (ASM_OPERANDS_INPUT_VEC (SET_SRC (XVECEXP (x, 0, 0)))
|
== ASM_OPERANDS_INPUT_VEC (SET_SRC (XVECEXP
|
== ASM_OPERANDS_INPUT_VEC (SET_SRC (XVECEXP
|
(x, 0, j))));
|
(x, 0, j))));
|
validate_replace_rtx_1 (&SET_DEST (XVECEXP (x, 0, j)),
|
validate_replace_rtx_1 (&SET_DEST (XVECEXP (x, 0, j)),
|
from, to, object);
|
from, to, object);
|
}
|
}
|
else
|
else
|
validate_replace_rtx_1 (&XVECEXP (x, 0, j), from, to, object);
|
validate_replace_rtx_1 (&XVECEXP (x, 0, j), from, to, object);
|
}
|
}
|
}
|
}
|
else
|
else
|
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')
|
validate_replace_rtx_1 (&XEXP (x, i), from, to, object);
|
validate_replace_rtx_1 (&XEXP (x, i), from, to, object);
|
else if (fmt[i] == 'E')
|
else if (fmt[i] == 'E')
|
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
validate_replace_rtx_1 (&XVECEXP (x, i, j), from, to, object);
|
validate_replace_rtx_1 (&XVECEXP (x, i, j), from, to, object);
|
}
|
}
|
|
|
/* If we didn't substitute, there is nothing more to do. */
|
/* If we didn't substitute, there is nothing more to do. */
|
if (num_changes == prev_changes)
|
if (num_changes == prev_changes)
|
return;
|
return;
|
|
|
/* Allow substituted expression to have different mode. This is used by
|
/* Allow substituted expression to have different mode. This is used by
|
regmove to change mode of pseudo register. */
|
regmove to change mode of pseudo register. */
|
if (fmt[0] == 'e' && GET_MODE (XEXP (x, 0)) != VOIDmode)
|
if (fmt[0] == 'e' && GET_MODE (XEXP (x, 0)) != VOIDmode)
|
op0_mode = GET_MODE (XEXP (x, 0));
|
op0_mode = GET_MODE (XEXP (x, 0));
|
|
|
/* Do changes needed to keep rtx consistent. Don't do any other
|
/* Do changes needed to keep rtx consistent. Don't do any other
|
simplifications, as it is not our job. */
|
simplifications, as it is not our job. */
|
|
|
if (SWAPPABLE_OPERANDS_P (x)
|
if (SWAPPABLE_OPERANDS_P (x)
|
&& swap_commutative_operands_p (XEXP (x, 0), XEXP (x, 1)))
|
&& swap_commutative_operands_p (XEXP (x, 0), XEXP (x, 1)))
|
{
|
{
|
validate_change (object, loc,
|
validate_change (object, loc,
|
gen_rtx_fmt_ee (COMMUTATIVE_ARITH_P (x) ? code
|
gen_rtx_fmt_ee (COMMUTATIVE_ARITH_P (x) ? code
|
: swap_condition (code),
|
: swap_condition (code),
|
GET_MODE (x), XEXP (x, 1),
|
GET_MODE (x), XEXP (x, 1),
|
XEXP (x, 0)), 1);
|
XEXP (x, 0)), 1);
|
x = *loc;
|
x = *loc;
|
code = GET_CODE (x);
|
code = GET_CODE (x);
|
}
|
}
|
|
|
switch (code)
|
switch (code)
|
{
|
{
|
case PLUS:
|
case PLUS:
|
/* If we have a PLUS whose second operand is now a CONST_INT, use
|
/* If we have a PLUS whose second operand is now a CONST_INT, use
|
simplify_gen_binary to try to simplify it.
|
simplify_gen_binary to try to simplify it.
|
??? We may want later to remove this, once simplification is
|
??? We may want later to remove this, once simplification is
|
separated from this function. */
|
separated from this function. */
|
if (GET_CODE (XEXP (x, 1)) == CONST_INT && XEXP (x, 1) == to)
|
if (GET_CODE (XEXP (x, 1)) == CONST_INT && XEXP (x, 1) == to)
|
validate_change (object, loc,
|
validate_change (object, loc,
|
simplify_gen_binary
|
simplify_gen_binary
|
(PLUS, GET_MODE (x), XEXP (x, 0), XEXP (x, 1)), 1);
|
(PLUS, GET_MODE (x), XEXP (x, 0), XEXP (x, 1)), 1);
|
break;
|
break;
|
case MINUS:
|
case MINUS:
|
if (GET_CODE (XEXP (x, 1)) == CONST_INT
|
if (GET_CODE (XEXP (x, 1)) == CONST_INT
|
|| GET_CODE (XEXP (x, 1)) == CONST_DOUBLE)
|
|| GET_CODE (XEXP (x, 1)) == CONST_DOUBLE)
|
validate_change (object, loc,
|
validate_change (object, loc,
|
simplify_gen_binary
|
simplify_gen_binary
|
(PLUS, GET_MODE (x), XEXP (x, 0),
|
(PLUS, GET_MODE (x), XEXP (x, 0),
|
simplify_gen_unary (NEG,
|
simplify_gen_unary (NEG,
|
GET_MODE (x), XEXP (x, 1),
|
GET_MODE (x), XEXP (x, 1),
|
GET_MODE (x))), 1);
|
GET_MODE (x))), 1);
|
break;
|
break;
|
case ZERO_EXTEND:
|
case ZERO_EXTEND:
|
case SIGN_EXTEND:
|
case SIGN_EXTEND:
|
if (GET_MODE (XEXP (x, 0)) == VOIDmode)
|
if (GET_MODE (XEXP (x, 0)) == VOIDmode)
|
{
|
{
|
new = simplify_gen_unary (code, GET_MODE (x), XEXP (x, 0),
|
new = simplify_gen_unary (code, GET_MODE (x), XEXP (x, 0),
|
op0_mode);
|
op0_mode);
|
/* If any of the above failed, substitute in something that
|
/* If any of the above failed, substitute in something that
|
we know won't be recognized. */
|
we know won't be recognized. */
|
if (!new)
|
if (!new)
|
new = gen_rtx_CLOBBER (GET_MODE (x), const0_rtx);
|
new = gen_rtx_CLOBBER (GET_MODE (x), const0_rtx);
|
validate_change (object, loc, new, 1);
|
validate_change (object, loc, new, 1);
|
}
|
}
|
break;
|
break;
|
case SUBREG:
|
case SUBREG:
|
/* All subregs possible to simplify should be simplified. */
|
/* All subregs possible to simplify should be simplified. */
|
new = simplify_subreg (GET_MODE (x), SUBREG_REG (x), op0_mode,
|
new = simplify_subreg (GET_MODE (x), SUBREG_REG (x), op0_mode,
|
SUBREG_BYTE (x));
|
SUBREG_BYTE (x));
|
|
|
/* Subregs of VOIDmode operands are incorrect. */
|
/* Subregs of VOIDmode operands are incorrect. */
|
if (!new && GET_MODE (SUBREG_REG (x)) == VOIDmode)
|
if (!new && GET_MODE (SUBREG_REG (x)) == VOIDmode)
|
new = gen_rtx_CLOBBER (GET_MODE (x), const0_rtx);
|
new = gen_rtx_CLOBBER (GET_MODE (x), const0_rtx);
|
if (new)
|
if (new)
|
validate_change (object, loc, new, 1);
|
validate_change (object, loc, new, 1);
|
break;
|
break;
|
case ZERO_EXTRACT:
|
case ZERO_EXTRACT:
|
case SIGN_EXTRACT:
|
case SIGN_EXTRACT:
|
/* If we are replacing a register with memory, try to change the memory
|
/* If we are replacing a register with memory, try to change the memory
|
to be the mode required for memory in extract operations (this isn't
|
to be the mode required for memory in extract operations (this isn't
|
likely to be an insertion operation; if it was, nothing bad will
|
likely to be an insertion operation; if it was, nothing bad will
|
happen, we might just fail in some cases). */
|
happen, we might just fail in some cases). */
|
|
|
if (MEM_P (XEXP (x, 0))
|
if (MEM_P (XEXP (x, 0))
|
&& GET_CODE (XEXP (x, 1)) == CONST_INT
|
&& GET_CODE (XEXP (x, 1)) == CONST_INT
|
&& GET_CODE (XEXP (x, 2)) == CONST_INT
|
&& GET_CODE (XEXP (x, 2)) == CONST_INT
|
&& !mode_dependent_address_p (XEXP (XEXP (x, 0), 0))
|
&& !mode_dependent_address_p (XEXP (XEXP (x, 0), 0))
|
&& !MEM_VOLATILE_P (XEXP (x, 0)))
|
&& !MEM_VOLATILE_P (XEXP (x, 0)))
|
{
|
{
|
enum machine_mode wanted_mode = VOIDmode;
|
enum machine_mode wanted_mode = VOIDmode;
|
enum machine_mode is_mode = GET_MODE (XEXP (x, 0));
|
enum machine_mode is_mode = GET_MODE (XEXP (x, 0));
|
int pos = INTVAL (XEXP (x, 2));
|
int pos = INTVAL (XEXP (x, 2));
|
|
|
if (GET_CODE (x) == ZERO_EXTRACT)
|
if (GET_CODE (x) == ZERO_EXTRACT)
|
{
|
{
|
enum machine_mode new_mode
|
enum machine_mode new_mode
|
= mode_for_extraction (EP_extzv, 1);
|
= mode_for_extraction (EP_extzv, 1);
|
if (new_mode != MAX_MACHINE_MODE)
|
if (new_mode != MAX_MACHINE_MODE)
|
wanted_mode = new_mode;
|
wanted_mode = new_mode;
|
}
|
}
|
else if (GET_CODE (x) == SIGN_EXTRACT)
|
else if (GET_CODE (x) == SIGN_EXTRACT)
|
{
|
{
|
enum machine_mode new_mode
|
enum machine_mode new_mode
|
= mode_for_extraction (EP_extv, 1);
|
= mode_for_extraction (EP_extv, 1);
|
if (new_mode != MAX_MACHINE_MODE)
|
if (new_mode != MAX_MACHINE_MODE)
|
wanted_mode = new_mode;
|
wanted_mode = new_mode;
|
}
|
}
|
|
|
/* If we have a narrower mode, we can do something. */
|
/* If we have a narrower mode, we can do something. */
|
if (wanted_mode != VOIDmode
|
if (wanted_mode != VOIDmode
|
&& GET_MODE_SIZE (wanted_mode) < GET_MODE_SIZE (is_mode))
|
&& GET_MODE_SIZE (wanted_mode) < GET_MODE_SIZE (is_mode))
|
{
|
{
|
int offset = pos / BITS_PER_UNIT;
|
int offset = pos / BITS_PER_UNIT;
|
rtx newmem;
|
rtx newmem;
|
|
|
/* If the bytes and bits are counted differently, we
|
/* If the bytes and bits are counted differently, we
|
must adjust the offset. */
|
must adjust the offset. */
|
if (BYTES_BIG_ENDIAN != BITS_BIG_ENDIAN)
|
if (BYTES_BIG_ENDIAN != BITS_BIG_ENDIAN)
|
offset =
|
offset =
|
(GET_MODE_SIZE (is_mode) - GET_MODE_SIZE (wanted_mode) -
|
(GET_MODE_SIZE (is_mode) - GET_MODE_SIZE (wanted_mode) -
|
offset);
|
offset);
|
|
|
pos %= GET_MODE_BITSIZE (wanted_mode);
|
pos %= GET_MODE_BITSIZE (wanted_mode);
|
|
|
newmem = adjust_address_nv (XEXP (x, 0), wanted_mode, offset);
|
newmem = adjust_address_nv (XEXP (x, 0), wanted_mode, offset);
|
|
|
validate_change (object, &XEXP (x, 2), GEN_INT (pos), 1);
|
validate_change (object, &XEXP (x, 2), GEN_INT (pos), 1);
|
validate_change (object, &XEXP (x, 0), newmem, 1);
|
validate_change (object, &XEXP (x, 0), newmem, 1);
|
}
|
}
|
}
|
}
|
|
|
break;
|
break;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
/* Try replacing every occurrence of FROM in INSN with TO. After all
|
/* Try replacing every occurrence of FROM in INSN with TO. After all
|
changes have been made, validate by seeing if INSN is still valid. */
|
changes have been made, validate by seeing if INSN is still valid. */
|
|
|
int
|
int
|
validate_replace_rtx (rtx from, rtx to, rtx insn)
|
validate_replace_rtx (rtx from, rtx to, rtx insn)
|
{
|
{
|
validate_replace_rtx_1 (&PATTERN (insn), from, to, insn);
|
validate_replace_rtx_1 (&PATTERN (insn), from, to, insn);
|
return apply_change_group ();
|
return apply_change_group ();
|
}
|
}
|
|
|
/* Try replacing every occurrence of FROM in INSN with TO. */
|
/* Try replacing every occurrence of FROM in INSN with TO. */
|
|
|
void
|
void
|
validate_replace_rtx_group (rtx from, rtx to, rtx insn)
|
validate_replace_rtx_group (rtx from, rtx to, rtx insn)
|
{
|
{
|
validate_replace_rtx_1 (&PATTERN (insn), from, to, insn);
|
validate_replace_rtx_1 (&PATTERN (insn), from, to, insn);
|
}
|
}
|
|
|
/* Function called by note_uses to replace used subexpressions. */
|
/* Function called by note_uses to replace used subexpressions. */
|
struct validate_replace_src_data
|
struct validate_replace_src_data
|
{
|
{
|
rtx from; /* Old RTX */
|
rtx from; /* Old RTX */
|
rtx to; /* New RTX */
|
rtx to; /* New RTX */
|
rtx insn; /* Insn in which substitution is occurring. */
|
rtx insn; /* Insn in which substitution is occurring. */
|
};
|
};
|
|
|
static void
|
static void
|
validate_replace_src_1 (rtx *x, void *data)
|
validate_replace_src_1 (rtx *x, void *data)
|
{
|
{
|
struct validate_replace_src_data *d
|
struct validate_replace_src_data *d
|
= (struct validate_replace_src_data *) data;
|
= (struct validate_replace_src_data *) data;
|
|
|
validate_replace_rtx_1 (x, d->from, d->to, d->insn);
|
validate_replace_rtx_1 (x, d->from, d->to, d->insn);
|
}
|
}
|
|
|
/* Try replacing every occurrence of FROM in INSN with TO, avoiding
|
/* Try replacing every occurrence of FROM in INSN with TO, avoiding
|
SET_DESTs. */
|
SET_DESTs. */
|
|
|
void
|
void
|
validate_replace_src_group (rtx from, rtx to, rtx insn)
|
validate_replace_src_group (rtx from, rtx to, rtx insn)
|
{
|
{
|
struct validate_replace_src_data d;
|
struct validate_replace_src_data d;
|
|
|
d.from = from;
|
d.from = from;
|
d.to = to;
|
d.to = to;
|
d.insn = insn;
|
d.insn = insn;
|
note_uses (&PATTERN (insn), validate_replace_src_1, &d);
|
note_uses (&PATTERN (insn), validate_replace_src_1, &d);
|
}
|
}
|
|
|
/* Try simplify INSN.
|
/* Try simplify INSN.
|
Invoke simplify_rtx () on every SET_SRC and SET_DEST inside the INSN's
|
Invoke simplify_rtx () on every SET_SRC and SET_DEST inside the INSN's
|
pattern and return true if something was simplified. */
|
pattern and return true if something was simplified. */
|
|
|
bool
|
bool
|
validate_simplify_insn (rtx insn)
|
validate_simplify_insn (rtx insn)
|
{
|
{
|
int i;
|
int i;
|
rtx pat = NULL;
|
rtx pat = NULL;
|
rtx newpat = NULL;
|
rtx newpat = NULL;
|
|
|
pat = PATTERN (insn);
|
pat = PATTERN (insn);
|
|
|
if (GET_CODE (pat) == SET)
|
if (GET_CODE (pat) == SET)
|
{
|
{
|
newpat = simplify_rtx (SET_SRC (pat));
|
newpat = simplify_rtx (SET_SRC (pat));
|
if (newpat && !rtx_equal_p (SET_SRC (pat), newpat))
|
if (newpat && !rtx_equal_p (SET_SRC (pat), newpat))
|
validate_change (insn, &SET_SRC (pat), newpat, 1);
|
validate_change (insn, &SET_SRC (pat), newpat, 1);
|
newpat = simplify_rtx (SET_DEST (pat));
|
newpat = simplify_rtx (SET_DEST (pat));
|
if (newpat && !rtx_equal_p (SET_DEST (pat), newpat))
|
if (newpat && !rtx_equal_p (SET_DEST (pat), newpat))
|
validate_change (insn, &SET_DEST (pat), newpat, 1);
|
validate_change (insn, &SET_DEST (pat), newpat, 1);
|
}
|
}
|
else if (GET_CODE (pat) == PARALLEL)
|
else if (GET_CODE (pat) == PARALLEL)
|
for (i = 0; i < XVECLEN (pat, 0); i++)
|
for (i = 0; i < XVECLEN (pat, 0); i++)
|
{
|
{
|
rtx s = XVECEXP (pat, 0, i);
|
rtx s = XVECEXP (pat, 0, i);
|
|
|
if (GET_CODE (XVECEXP (pat, 0, i)) == SET)
|
if (GET_CODE (XVECEXP (pat, 0, i)) == SET)
|
{
|
{
|
newpat = simplify_rtx (SET_SRC (s));
|
newpat = simplify_rtx (SET_SRC (s));
|
if (newpat && !rtx_equal_p (SET_SRC (s), newpat))
|
if (newpat && !rtx_equal_p (SET_SRC (s), newpat))
|
validate_change (insn, &SET_SRC (s), newpat, 1);
|
validate_change (insn, &SET_SRC (s), newpat, 1);
|
newpat = simplify_rtx (SET_DEST (s));
|
newpat = simplify_rtx (SET_DEST (s));
|
if (newpat && !rtx_equal_p (SET_DEST (s), newpat))
|
if (newpat && !rtx_equal_p (SET_DEST (s), newpat))
|
validate_change (insn, &SET_DEST (s), newpat, 1);
|
validate_change (insn, &SET_DEST (s), newpat, 1);
|
}
|
}
|
}
|
}
|
return ((num_changes_pending () > 0) && (apply_change_group () > 0));
|
return ((num_changes_pending () > 0) && (apply_change_group () > 0));
|
}
|
}
|
|
|
#ifdef HAVE_cc0
|
#ifdef HAVE_cc0
|
/* Return 1 if the insn using CC0 set by INSN does not contain
|
/* Return 1 if the insn using CC0 set by INSN does not contain
|
any ordered tests applied to the condition codes.
|
any ordered tests applied to the condition codes.
|
EQ and NE tests do not count. */
|
EQ and NE tests do not count. */
|
|
|
int
|
int
|
next_insn_tests_no_inequality (rtx insn)
|
next_insn_tests_no_inequality (rtx insn)
|
{
|
{
|
rtx next = next_cc0_user (insn);
|
rtx next = next_cc0_user (insn);
|
|
|
/* If there is no next insn, we have to take the conservative choice. */
|
/* If there is no next insn, we have to take the conservative choice. */
|
if (next == 0)
|
if (next == 0)
|
return 0;
|
return 0;
|
|
|
return (INSN_P (next)
|
return (INSN_P (next)
|
&& ! inequality_comparisons_p (PATTERN (next)));
|
&& ! inequality_comparisons_p (PATTERN (next)));
|
}
|
}
|
#endif
|
#endif
|
|
|
/* This is used by find_single_use to locate an rtx that contains exactly one
|
/* This is used by find_single_use to locate an rtx that contains exactly one
|
use of DEST, which is typically either a REG or CC0. It returns a
|
use of DEST, which is typically either a REG or CC0. It returns a
|
pointer to the innermost rtx expression containing DEST. Appearances of
|
pointer to the innermost rtx expression containing DEST. Appearances of
|
DEST that are being used to totally replace it are not counted. */
|
DEST that are being used to totally replace it are not counted. */
|
|
|
static rtx *
|
static rtx *
|
find_single_use_1 (rtx dest, rtx *loc)
|
find_single_use_1 (rtx dest, rtx *loc)
|
{
|
{
|
rtx x = *loc;
|
rtx x = *loc;
|
enum rtx_code code = GET_CODE (x);
|
enum rtx_code code = GET_CODE (x);
|
rtx *result = 0;
|
rtx *result = 0;
|
rtx *this_result;
|
rtx *this_result;
|
int i;
|
int i;
|
const char *fmt;
|
const char *fmt;
|
|
|
switch (code)
|
switch (code)
|
{
|
{
|
case CONST_INT:
|
case CONST_INT:
|
case CONST:
|
case CONST:
|
case LABEL_REF:
|
case LABEL_REF:
|
case SYMBOL_REF:
|
case SYMBOL_REF:
|
case CONST_DOUBLE:
|
case CONST_DOUBLE:
|
case CONST_VECTOR:
|
case CONST_VECTOR:
|
case CLOBBER:
|
case CLOBBER:
|
return 0;
|
return 0;
|
|
|
case SET:
|
case SET:
|
/* If the destination is anything other than CC0, PC, a REG or a SUBREG
|
/* If the destination is anything other than CC0, PC, a REG or a SUBREG
|
of a REG that occupies all of the REG, the insn uses DEST if
|
of a REG that occupies all of the REG, the insn uses DEST if
|
it is mentioned in the destination or the source. Otherwise, we
|
it is mentioned in the destination or the source. Otherwise, we
|
need just check the source. */
|
need just check the source. */
|
if (GET_CODE (SET_DEST (x)) != CC0
|
if (GET_CODE (SET_DEST (x)) != CC0
|
&& GET_CODE (SET_DEST (x)) != PC
|
&& GET_CODE (SET_DEST (x)) != PC
|
&& !REG_P (SET_DEST (x))
|
&& !REG_P (SET_DEST (x))
|
&& ! (GET_CODE (SET_DEST (x)) == SUBREG
|
&& ! (GET_CODE (SET_DEST (x)) == SUBREG
|
&& REG_P (SUBREG_REG (SET_DEST (x)))
|
&& REG_P (SUBREG_REG (SET_DEST (x)))
|
&& (((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (x))))
|
&& (((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (x))))
|
+ (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
|
+ (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
|
== ((GET_MODE_SIZE (GET_MODE (SET_DEST (x)))
|
== ((GET_MODE_SIZE (GET_MODE (SET_DEST (x)))
|
+ (UNITS_PER_WORD - 1)) / UNITS_PER_WORD))))
|
+ (UNITS_PER_WORD - 1)) / UNITS_PER_WORD))))
|
break;
|
break;
|
|
|
return find_single_use_1 (dest, &SET_SRC (x));
|
return find_single_use_1 (dest, &SET_SRC (x));
|
|
|
case MEM:
|
case MEM:
|
case SUBREG:
|
case SUBREG:
|
return find_single_use_1 (dest, &XEXP (x, 0));
|
return find_single_use_1 (dest, &XEXP (x, 0));
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
/* If it wasn't one of the common cases above, check each expression and
|
/* If it wasn't one of the common cases above, check each expression and
|
vector of this code. Look for a unique usage of DEST. */
|
vector of this code. Look for a unique usage of DEST. */
|
|
|
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')
|
{
|
{
|
if (dest == XEXP (x, i)
|
if (dest == XEXP (x, i)
|
|| (REG_P (dest) && REG_P (XEXP (x, i))
|
|| (REG_P (dest) && REG_P (XEXP (x, i))
|
&& REGNO (dest) == REGNO (XEXP (x, i))))
|
&& REGNO (dest) == REGNO (XEXP (x, i))))
|
this_result = loc;
|
this_result = loc;
|
else
|
else
|
this_result = find_single_use_1 (dest, &XEXP (x, i));
|
this_result = find_single_use_1 (dest, &XEXP (x, i));
|
|
|
if (result == 0)
|
if (result == 0)
|
result = this_result;
|
result = this_result;
|
else if (this_result)
|
else if (this_result)
|
/* Duplicate usage. */
|
/* Duplicate usage. */
|
return 0;
|
return 0;
|
}
|
}
|
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 (XVECEXP (x, i, j) == dest
|
if (XVECEXP (x, i, j) == dest
|
|| (REG_P (dest)
|
|| (REG_P (dest)
|
&& REG_P (XVECEXP (x, i, j))
|
&& REG_P (XVECEXP (x, i, j))
|
&& REGNO (XVECEXP (x, i, j)) == REGNO (dest)))
|
&& REGNO (XVECEXP (x, i, j)) == REGNO (dest)))
|
this_result = loc;
|
this_result = loc;
|
else
|
else
|
this_result = find_single_use_1 (dest, &XVECEXP (x, i, j));
|
this_result = find_single_use_1 (dest, &XVECEXP (x, i, j));
|
|
|
if (result == 0)
|
if (result == 0)
|
result = this_result;
|
result = this_result;
|
else if (this_result)
|
else if (this_result)
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
return result;
|
return result;
|
}
|
}
|
|
|
/* See if DEST, produced in INSN, is used only a single time in the
|
/* See if DEST, produced in INSN, is used only a single time in the
|
sequel. If so, return a pointer to the innermost rtx expression in which
|
sequel. If so, return a pointer to the innermost rtx expression in which
|
it is used.
|
it is used.
|
|
|
If PLOC is nonzero, *PLOC is set to the insn containing the single use.
|
If PLOC is nonzero, *PLOC is set to the insn containing the single use.
|
|
|
This routine will return usually zero either before flow is called (because
|
This routine will return usually zero either before flow is called (because
|
there will be no LOG_LINKS notes) or after reload (because the REG_DEAD
|
there will be no LOG_LINKS notes) or after reload (because the REG_DEAD
|
note can't be trusted).
|
note can't be trusted).
|
|
|
If DEST is cc0_rtx, we look only at the next insn. In that case, we don't
|
If DEST is cc0_rtx, we look only at the next insn. In that case, we don't
|
care about REG_DEAD notes or LOG_LINKS.
|
care about REG_DEAD notes or LOG_LINKS.
|
|
|
Otherwise, we find the single use by finding an insn that has a
|
Otherwise, we find the single use by finding an insn that has a
|
LOG_LINKS pointing at INSN and has a REG_DEAD note for DEST. If DEST is
|
LOG_LINKS pointing at INSN and has a REG_DEAD note for DEST. If DEST is
|
only referenced once in that insn, we know that it must be the first
|
only referenced once in that insn, we know that it must be the first
|
and last insn referencing DEST. */
|
and last insn referencing DEST. */
|
|
|
rtx *
|
rtx *
|
find_single_use (rtx dest, rtx insn, rtx *ploc)
|
find_single_use (rtx dest, rtx insn, rtx *ploc)
|
{
|
{
|
rtx next;
|
rtx next;
|
rtx *result;
|
rtx *result;
|
rtx link;
|
rtx link;
|
|
|
#ifdef HAVE_cc0
|
#ifdef HAVE_cc0
|
if (dest == cc0_rtx)
|
if (dest == cc0_rtx)
|
{
|
{
|
next = NEXT_INSN (insn);
|
next = NEXT_INSN (insn);
|
if (next == 0
|
if (next == 0
|
|| (!NONJUMP_INSN_P (next) && !JUMP_P (next)))
|
|| (!NONJUMP_INSN_P (next) && !JUMP_P (next)))
|
return 0;
|
return 0;
|
|
|
result = find_single_use_1 (dest, &PATTERN (next));
|
result = find_single_use_1 (dest, &PATTERN (next));
|
if (result && ploc)
|
if (result && ploc)
|
*ploc = next;
|
*ploc = next;
|
return result;
|
return result;
|
}
|
}
|
#endif
|
#endif
|
|
|
if (reload_completed || reload_in_progress || !REG_P (dest))
|
if (reload_completed || reload_in_progress || !REG_P (dest))
|
return 0;
|
return 0;
|
|
|
for (next = next_nonnote_insn (insn);
|
for (next = next_nonnote_insn (insn);
|
next != 0 && !LABEL_P (next);
|
next != 0 && !LABEL_P (next);
|
next = next_nonnote_insn (next))
|
next = next_nonnote_insn (next))
|
if (INSN_P (next) && dead_or_set_p (next, dest))
|
if (INSN_P (next) && dead_or_set_p (next, dest))
|
{
|
{
|
for (link = LOG_LINKS (next); link; link = XEXP (link, 1))
|
for (link = LOG_LINKS (next); link; link = XEXP (link, 1))
|
if (XEXP (link, 0) == insn)
|
if (XEXP (link, 0) == insn)
|
break;
|
break;
|
|
|
if (link)
|
if (link)
|
{
|
{
|
result = find_single_use_1 (dest, &PATTERN (next));
|
result = find_single_use_1 (dest, &PATTERN (next));
|
if (ploc)
|
if (ploc)
|
*ploc = next;
|
*ploc = next;
|
return result;
|
return result;
|
}
|
}
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Return 1 if OP is a valid general operand for machine mode MODE.
|
/* Return 1 if OP is a valid general operand for machine mode MODE.
|
This is either a register reference, a memory reference,
|
This is either a register reference, a memory reference,
|
or a constant. In the case of a memory reference, the address
|
or a constant. In the case of a memory reference, the address
|
is checked for general validity for the target machine.
|
is checked for general validity for the target machine.
|
|
|
Register and memory references must have mode MODE in order to be valid,
|
Register and memory references must have mode MODE in order to be valid,
|
but some constants have no machine mode and are valid for any mode.
|
but some constants have no machine mode and are valid for any mode.
|
|
|
If MODE is VOIDmode, OP is checked for validity for whatever mode
|
If MODE is VOIDmode, OP is checked for validity for whatever mode
|
it has.
|
it has.
|
|
|
The main use of this function is as a predicate in match_operand
|
The main use of this function is as a predicate in match_operand
|
expressions in the machine description.
|
expressions in the machine description.
|
|
|
For an explanation of this function's behavior for registers of
|
For an explanation of this function's behavior for registers of
|
class NO_REGS, see the comment for `register_operand'. */
|
class NO_REGS, see the comment for `register_operand'. */
|
|
|
int
|
int
|
general_operand (rtx op, enum machine_mode mode)
|
general_operand (rtx op, enum machine_mode mode)
|
{
|
{
|
enum rtx_code code = GET_CODE (op);
|
enum rtx_code code = GET_CODE (op);
|
|
|
if (mode == VOIDmode)
|
if (mode == VOIDmode)
|
mode = GET_MODE (op);
|
mode = GET_MODE (op);
|
|
|
/* Don't accept CONST_INT or anything similar
|
/* Don't accept CONST_INT or anything similar
|
if the caller wants something floating. */
|
if the caller wants something floating. */
|
if (GET_MODE (op) == VOIDmode && mode != VOIDmode
|
if (GET_MODE (op) == VOIDmode && mode != VOIDmode
|
&& GET_MODE_CLASS (mode) != MODE_INT
|
&& GET_MODE_CLASS (mode) != MODE_INT
|
&& GET_MODE_CLASS (mode) != MODE_PARTIAL_INT)
|
&& GET_MODE_CLASS (mode) != MODE_PARTIAL_INT)
|
return 0;
|
return 0;
|
|
|
if (GET_CODE (op) == CONST_INT
|
if (GET_CODE (op) == CONST_INT
|
&& mode != VOIDmode
|
&& mode != VOIDmode
|
&& trunc_int_for_mode (INTVAL (op), mode) != INTVAL (op))
|
&& trunc_int_for_mode (INTVAL (op), mode) != INTVAL (op))
|
return 0;
|
return 0;
|
|
|
if (CONSTANT_P (op))
|
if (CONSTANT_P (op))
|
return ((GET_MODE (op) == VOIDmode || GET_MODE (op) == mode
|
return ((GET_MODE (op) == VOIDmode || GET_MODE (op) == mode
|
|| mode == VOIDmode)
|
|| mode == VOIDmode)
|
&& (! flag_pic || LEGITIMATE_PIC_OPERAND_P (op))
|
&& (! flag_pic || LEGITIMATE_PIC_OPERAND_P (op))
|
&& LEGITIMATE_CONSTANT_P (op));
|
&& LEGITIMATE_CONSTANT_P (op));
|
|
|
/* Except for certain constants with VOIDmode, already checked for,
|
/* Except for certain constants with VOIDmode, already checked for,
|
OP's mode must match MODE if MODE specifies a mode. */
|
OP's mode must match MODE if MODE specifies a mode. */
|
|
|
if (GET_MODE (op) != mode)
|
if (GET_MODE (op) != mode)
|
return 0;
|
return 0;
|
|
|
if (code == SUBREG)
|
if (code == SUBREG)
|
{
|
{
|
rtx sub = SUBREG_REG (op);
|
rtx sub = SUBREG_REG (op);
|
|
|
#ifdef INSN_SCHEDULING
|
#ifdef INSN_SCHEDULING
|
/* On machines that have insn scheduling, we want all memory
|
/* On machines that have insn scheduling, we want all memory
|
reference to be explicit, so outlaw paradoxical SUBREGs.
|
reference to be explicit, so outlaw paradoxical SUBREGs.
|
However, we must allow them after reload so that they can
|
However, we must allow them after reload so that they can
|
get cleaned up by cleanup_subreg_operands. */
|
get cleaned up by cleanup_subreg_operands. */
|
if (!reload_completed && MEM_P (sub)
|
if (!reload_completed && MEM_P (sub)
|
&& GET_MODE_SIZE (mode) > GET_MODE_SIZE (GET_MODE (sub)))
|
&& GET_MODE_SIZE (mode) > GET_MODE_SIZE (GET_MODE (sub)))
|
return 0;
|
return 0;
|
#endif
|
#endif
|
/* Avoid memories with nonzero SUBREG_BYTE, as offsetting the memory
|
/* Avoid memories with nonzero SUBREG_BYTE, as offsetting the memory
|
may result in incorrect reference. We should simplify all valid
|
may result in incorrect reference. We should simplify all valid
|
subregs of MEM anyway. But allow this after reload because we
|
subregs of MEM anyway. But allow this after reload because we
|
might be called from cleanup_subreg_operands.
|
might be called from cleanup_subreg_operands.
|
|
|
??? This is a kludge. */
|
??? This is a kludge. */
|
if (!reload_completed && SUBREG_BYTE (op) != 0
|
if (!reload_completed && SUBREG_BYTE (op) != 0
|
&& MEM_P (sub))
|
&& MEM_P (sub))
|
return 0;
|
return 0;
|
|
|
/* FLOAT_MODE subregs can't be paradoxical. Combine will occasionally
|
/* FLOAT_MODE subregs can't be paradoxical. Combine will occasionally
|
create such rtl, and we must reject it. */
|
create such rtl, and we must reject it. */
|
if (SCALAR_FLOAT_MODE_P (GET_MODE (op))
|
if (SCALAR_FLOAT_MODE_P (GET_MODE (op))
|
&& GET_MODE_SIZE (GET_MODE (op)) > GET_MODE_SIZE (GET_MODE (sub)))
|
&& GET_MODE_SIZE (GET_MODE (op)) > GET_MODE_SIZE (GET_MODE (sub)))
|
return 0;
|
return 0;
|
|
|
op = sub;
|
op = sub;
|
code = GET_CODE (op);
|
code = GET_CODE (op);
|
}
|
}
|
|
|
if (code == REG)
|
if (code == REG)
|
/* A register whose class is NO_REGS is not a general operand. */
|
/* A register whose class is NO_REGS is not a general operand. */
|
return (REGNO (op) >= FIRST_PSEUDO_REGISTER
|
return (REGNO (op) >= FIRST_PSEUDO_REGISTER
|
|| REGNO_REG_CLASS (REGNO (op)) != NO_REGS);
|
|| REGNO_REG_CLASS (REGNO (op)) != NO_REGS);
|
|
|
if (code == MEM)
|
if (code == MEM)
|
{
|
{
|
rtx y = XEXP (op, 0);
|
rtx y = XEXP (op, 0);
|
|
|
if (! volatile_ok && MEM_VOLATILE_P (op))
|
if (! volatile_ok && MEM_VOLATILE_P (op))
|
return 0;
|
return 0;
|
|
|
/* Use the mem's mode, since it will be reloaded thus. */
|
/* Use the mem's mode, since it will be reloaded thus. */
|
if (memory_address_p (GET_MODE (op), y))
|
if (memory_address_p (GET_MODE (op), y))
|
return 1;
|
return 1;
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Return 1 if OP is a valid memory address for a memory reference
|
/* Return 1 if OP is a valid memory address for a memory reference
|
of mode MODE.
|
of mode MODE.
|
|
|
The main use of this function is as a predicate in match_operand
|
The main use of this function is as a predicate in match_operand
|
expressions in the machine description. */
|
expressions in the machine description. */
|
|
|
int
|
int
|
address_operand (rtx op, enum machine_mode mode)
|
address_operand (rtx op, enum machine_mode mode)
|
{
|
{
|
return memory_address_p (mode, op);
|
return memory_address_p (mode, op);
|
}
|
}
|
|
|
/* Return 1 if OP is a register reference of mode MODE.
|
/* Return 1 if OP is a register reference of mode MODE.
|
If MODE is VOIDmode, accept a register in any mode.
|
If MODE is VOIDmode, accept a register in any mode.
|
|
|
The main use of this function is as a predicate in match_operand
|
The main use of this function is as a predicate in match_operand
|
expressions in the machine description.
|
expressions in the machine description.
|
|
|
As a special exception, registers whose class is NO_REGS are
|
As a special exception, registers whose class is NO_REGS are
|
not accepted by `register_operand'. The reason for this change
|
not accepted by `register_operand'. The reason for this change
|
is to allow the representation of special architecture artifacts
|
is to allow the representation of special architecture artifacts
|
(such as a condition code register) without extending the rtl
|
(such as a condition code register) without extending the rtl
|
definitions. Since registers of class NO_REGS cannot be used
|
definitions. Since registers of class NO_REGS cannot be used
|
as registers in any case where register classes are examined,
|
as registers in any case where register classes are examined,
|
it is most consistent to keep this function from accepting them. */
|
it is most consistent to keep this function from accepting them. */
|
|
|
int
|
int
|
register_operand (rtx op, enum machine_mode mode)
|
register_operand (rtx op, enum machine_mode mode)
|
{
|
{
|
if (GET_MODE (op) != mode && mode != VOIDmode)
|
if (GET_MODE (op) != mode && mode != VOIDmode)
|
return 0;
|
return 0;
|
|
|
if (GET_CODE (op) == SUBREG)
|
if (GET_CODE (op) == SUBREG)
|
{
|
{
|
rtx sub = SUBREG_REG (op);
|
rtx sub = SUBREG_REG (op);
|
|
|
/* Before reload, we can allow (SUBREG (MEM...)) as a register operand
|
/* Before reload, we can allow (SUBREG (MEM...)) as a register operand
|
because it is guaranteed to be reloaded into one.
|
because it is guaranteed to be reloaded into one.
|
Just make sure the MEM is valid in itself.
|
Just make sure the MEM is valid in itself.
|
(Ideally, (SUBREG (MEM)...) should not exist after reload,
|
(Ideally, (SUBREG (MEM)...) should not exist after reload,
|
but currently it does result from (SUBREG (REG)...) where the
|
but currently it does result from (SUBREG (REG)...) where the
|
reg went on the stack.) */
|
reg went on the stack.) */
|
if (! reload_completed && MEM_P (sub))
|
if (! reload_completed && MEM_P (sub))
|
return general_operand (op, mode);
|
return general_operand (op, mode);
|
|
|
#ifdef CANNOT_CHANGE_MODE_CLASS
|
#ifdef CANNOT_CHANGE_MODE_CLASS
|
if (REG_P (sub)
|
if (REG_P (sub)
|
&& REGNO (sub) < FIRST_PSEUDO_REGISTER
|
&& REGNO (sub) < FIRST_PSEUDO_REGISTER
|
&& REG_CANNOT_CHANGE_MODE_P (REGNO (sub), GET_MODE (sub), mode)
|
&& REG_CANNOT_CHANGE_MODE_P (REGNO (sub), GET_MODE (sub), mode)
|
&& GET_MODE_CLASS (GET_MODE (sub)) != MODE_COMPLEX_INT
|
&& GET_MODE_CLASS (GET_MODE (sub)) != MODE_COMPLEX_INT
|
&& GET_MODE_CLASS (GET_MODE (sub)) != MODE_COMPLEX_FLOAT)
|
&& GET_MODE_CLASS (GET_MODE (sub)) != MODE_COMPLEX_FLOAT)
|
return 0;
|
return 0;
|
#endif
|
#endif
|
|
|
/* FLOAT_MODE subregs can't be paradoxical. Combine will occasionally
|
/* FLOAT_MODE subregs can't be paradoxical. Combine will occasionally
|
create such rtl, and we must reject it. */
|
create such rtl, and we must reject it. */
|
if (SCALAR_FLOAT_MODE_P (GET_MODE (op))
|
if (SCALAR_FLOAT_MODE_P (GET_MODE (op))
|
&& GET_MODE_SIZE (GET_MODE (op)) > GET_MODE_SIZE (GET_MODE (sub)))
|
&& GET_MODE_SIZE (GET_MODE (op)) > GET_MODE_SIZE (GET_MODE (sub)))
|
return 0;
|
return 0;
|
|
|
op = sub;
|
op = sub;
|
}
|
}
|
|
|
/* We don't consider registers whose class is NO_REGS
|
/* We don't consider registers whose class is NO_REGS
|
to be a register operand. */
|
to be a register operand. */
|
return (REG_P (op)
|
return (REG_P (op)
|
&& (REGNO (op) >= FIRST_PSEUDO_REGISTER
|
&& (REGNO (op) >= FIRST_PSEUDO_REGISTER
|
|| REGNO_REG_CLASS (REGNO (op)) != NO_REGS));
|
|| REGNO_REG_CLASS (REGNO (op)) != NO_REGS));
|
}
|
}
|
|
|
/* Return 1 for a register in Pmode; ignore the tested mode. */
|
/* Return 1 for a register in Pmode; ignore the tested mode. */
|
|
|
int
|
int
|
pmode_register_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
|
pmode_register_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
|
{
|
{
|
return register_operand (op, Pmode);
|
return register_operand (op, Pmode);
|
}
|
}
|
|
|
/* Return 1 if OP should match a MATCH_SCRATCH, i.e., if it is a SCRATCH
|
/* Return 1 if OP should match a MATCH_SCRATCH, i.e., if it is a SCRATCH
|
or a hard register. */
|
or a hard register. */
|
|
|
int
|
int
|
scratch_operand (rtx op, enum machine_mode mode)
|
scratch_operand (rtx op, enum machine_mode mode)
|
{
|
{
|
if (GET_MODE (op) != mode && mode != VOIDmode)
|
if (GET_MODE (op) != mode && mode != VOIDmode)
|
return 0;
|
return 0;
|
|
|
return (GET_CODE (op) == SCRATCH
|
return (GET_CODE (op) == SCRATCH
|
|| (REG_P (op)
|
|| (REG_P (op)
|
&& REGNO (op) < FIRST_PSEUDO_REGISTER));
|
&& REGNO (op) < FIRST_PSEUDO_REGISTER));
|
}
|
}
|
|
|
/* Return 1 if OP is a valid immediate operand for mode MODE.
|
/* Return 1 if OP is a valid immediate operand for mode MODE.
|
|
|
The main use of this function is as a predicate in match_operand
|
The main use of this function is as a predicate in match_operand
|
expressions in the machine description. */
|
expressions in the machine description. */
|
|
|
int
|
int
|
immediate_operand (rtx op, enum machine_mode mode)
|
immediate_operand (rtx op, enum machine_mode mode)
|
{
|
{
|
/* Don't accept CONST_INT or anything similar
|
/* Don't accept CONST_INT or anything similar
|
if the caller wants something floating. */
|
if the caller wants something floating. */
|
if (GET_MODE (op) == VOIDmode && mode != VOIDmode
|
if (GET_MODE (op) == VOIDmode && mode != VOIDmode
|
&& GET_MODE_CLASS (mode) != MODE_INT
|
&& GET_MODE_CLASS (mode) != MODE_INT
|
&& GET_MODE_CLASS (mode) != MODE_PARTIAL_INT)
|
&& GET_MODE_CLASS (mode) != MODE_PARTIAL_INT)
|
return 0;
|
return 0;
|
|
|
if (GET_CODE (op) == CONST_INT
|
if (GET_CODE (op) == CONST_INT
|
&& mode != VOIDmode
|
&& mode != VOIDmode
|
&& trunc_int_for_mode (INTVAL (op), mode) != INTVAL (op))
|
&& trunc_int_for_mode (INTVAL (op), mode) != INTVAL (op))
|
return 0;
|
return 0;
|
|
|
return (CONSTANT_P (op)
|
return (CONSTANT_P (op)
|
&& (GET_MODE (op) == mode || mode == VOIDmode
|
&& (GET_MODE (op) == mode || mode == VOIDmode
|
|| GET_MODE (op) == VOIDmode)
|
|| GET_MODE (op) == VOIDmode)
|
&& (! flag_pic || LEGITIMATE_PIC_OPERAND_P (op))
|
&& (! flag_pic || LEGITIMATE_PIC_OPERAND_P (op))
|
&& LEGITIMATE_CONSTANT_P (op));
|
&& LEGITIMATE_CONSTANT_P (op));
|
}
|
}
|
|
|
/* Returns 1 if OP is an operand that is a CONST_INT. */
|
/* Returns 1 if OP is an operand that is a CONST_INT. */
|
|
|
int
|
int
|
const_int_operand (rtx op, enum machine_mode mode)
|
const_int_operand (rtx op, enum machine_mode mode)
|
{
|
{
|
if (GET_CODE (op) != CONST_INT)
|
if (GET_CODE (op) != CONST_INT)
|
return 0;
|
return 0;
|
|
|
if (mode != VOIDmode
|
if (mode != VOIDmode
|
&& trunc_int_for_mode (INTVAL (op), mode) != INTVAL (op))
|
&& trunc_int_for_mode (INTVAL (op), mode) != INTVAL (op))
|
return 0;
|
return 0;
|
|
|
return 1;
|
return 1;
|
}
|
}
|
|
|
/* Returns 1 if OP is an operand that is a constant integer or constant
|
/* Returns 1 if OP is an operand that is a constant integer or constant
|
floating-point number. */
|
floating-point number. */
|
|
|
int
|
int
|
const_double_operand (rtx op, enum machine_mode mode)
|
const_double_operand (rtx op, enum machine_mode mode)
|
{
|
{
|
/* Don't accept CONST_INT or anything similar
|
/* Don't accept CONST_INT or anything similar
|
if the caller wants something floating. */
|
if the caller wants something floating. */
|
if (GET_MODE (op) == VOIDmode && mode != VOIDmode
|
if (GET_MODE (op) == VOIDmode && mode != VOIDmode
|
&& GET_MODE_CLASS (mode) != MODE_INT
|
&& GET_MODE_CLASS (mode) != MODE_INT
|
&& GET_MODE_CLASS (mode) != MODE_PARTIAL_INT)
|
&& GET_MODE_CLASS (mode) != MODE_PARTIAL_INT)
|
return 0;
|
return 0;
|
|
|
return ((GET_CODE (op) == CONST_DOUBLE || GET_CODE (op) == CONST_INT)
|
return ((GET_CODE (op) == CONST_DOUBLE || GET_CODE (op) == CONST_INT)
|
&& (mode == VOIDmode || GET_MODE (op) == mode
|
&& (mode == VOIDmode || GET_MODE (op) == mode
|
|| GET_MODE (op) == VOIDmode));
|
|| GET_MODE (op) == VOIDmode));
|
}
|
}
|
|
|
/* Return 1 if OP is a general operand that is not an immediate operand. */
|
/* Return 1 if OP is a general operand that is not an immediate operand. */
|
|
|
int
|
int
|
nonimmediate_operand (rtx op, enum machine_mode mode)
|
nonimmediate_operand (rtx op, enum machine_mode mode)
|
{
|
{
|
return (general_operand (op, mode) && ! CONSTANT_P (op));
|
return (general_operand (op, mode) && ! CONSTANT_P (op));
|
}
|
}
|
|
|
/* Return 1 if OP is a register reference or immediate value of mode MODE. */
|
/* Return 1 if OP is a register reference or immediate value of mode MODE. */
|
|
|
int
|
int
|
nonmemory_operand (rtx op, enum machine_mode mode)
|
nonmemory_operand (rtx op, enum machine_mode mode)
|
{
|
{
|
if (CONSTANT_P (op))
|
if (CONSTANT_P (op))
|
{
|
{
|
/* Don't accept CONST_INT or anything similar
|
/* Don't accept CONST_INT or anything similar
|
if the caller wants something floating. */
|
if the caller wants something floating. */
|
if (GET_MODE (op) == VOIDmode && mode != VOIDmode
|
if (GET_MODE (op) == VOIDmode && mode != VOIDmode
|
&& GET_MODE_CLASS (mode) != MODE_INT
|
&& GET_MODE_CLASS (mode) != MODE_INT
|
&& GET_MODE_CLASS (mode) != MODE_PARTIAL_INT)
|
&& GET_MODE_CLASS (mode) != MODE_PARTIAL_INT)
|
return 0;
|
return 0;
|
|
|
if (GET_CODE (op) == CONST_INT
|
if (GET_CODE (op) == CONST_INT
|
&& mode != VOIDmode
|
&& mode != VOIDmode
|
&& trunc_int_for_mode (INTVAL (op), mode) != INTVAL (op))
|
&& trunc_int_for_mode (INTVAL (op), mode) != INTVAL (op))
|
return 0;
|
return 0;
|
|
|
return ((GET_MODE (op) == VOIDmode || GET_MODE (op) == mode
|
return ((GET_MODE (op) == VOIDmode || GET_MODE (op) == mode
|
|| mode == VOIDmode)
|
|| mode == VOIDmode)
|
&& (! flag_pic || LEGITIMATE_PIC_OPERAND_P (op))
|
&& (! flag_pic || LEGITIMATE_PIC_OPERAND_P (op))
|
&& LEGITIMATE_CONSTANT_P (op));
|
&& LEGITIMATE_CONSTANT_P (op));
|
}
|
}
|
|
|
if (GET_MODE (op) != mode && mode != VOIDmode)
|
if (GET_MODE (op) != mode && mode != VOIDmode)
|
return 0;
|
return 0;
|
|
|
if (GET_CODE (op) == SUBREG)
|
if (GET_CODE (op) == SUBREG)
|
{
|
{
|
/* Before reload, we can allow (SUBREG (MEM...)) as a register operand
|
/* Before reload, we can allow (SUBREG (MEM...)) as a register operand
|
because it is guaranteed to be reloaded into one.
|
because it is guaranteed to be reloaded into one.
|
Just make sure the MEM is valid in itself.
|
Just make sure the MEM is valid in itself.
|
(Ideally, (SUBREG (MEM)...) should not exist after reload,
|
(Ideally, (SUBREG (MEM)...) should not exist after reload,
|
but currently it does result from (SUBREG (REG)...) where the
|
but currently it does result from (SUBREG (REG)...) where the
|
reg went on the stack.) */
|
reg went on the stack.) */
|
if (! reload_completed && MEM_P (SUBREG_REG (op)))
|
if (! reload_completed && MEM_P (SUBREG_REG (op)))
|
return general_operand (op, mode);
|
return general_operand (op, mode);
|
op = SUBREG_REG (op);
|
op = SUBREG_REG (op);
|
}
|
}
|
|
|
/* We don't consider registers whose class is NO_REGS
|
/* We don't consider registers whose class is NO_REGS
|
to be a register operand. */
|
to be a register operand. */
|
return (REG_P (op)
|
return (REG_P (op)
|
&& (REGNO (op) >= FIRST_PSEUDO_REGISTER
|
&& (REGNO (op) >= FIRST_PSEUDO_REGISTER
|
|| REGNO_REG_CLASS (REGNO (op)) != NO_REGS));
|
|| REGNO_REG_CLASS (REGNO (op)) != NO_REGS));
|
}
|
}
|
|
|
/* Return 1 if OP is a valid operand that stands for pushing a
|
/* Return 1 if OP is a valid operand that stands for pushing a
|
value of mode MODE onto the stack.
|
value of mode MODE onto the stack.
|
|
|
The main use of this function is as a predicate in match_operand
|
The main use of this function is as a predicate in match_operand
|
expressions in the machine description. */
|
expressions in the machine description. */
|
|
|
int
|
int
|
push_operand (rtx op, enum machine_mode mode)
|
push_operand (rtx op, enum machine_mode mode)
|
{
|
{
|
unsigned int rounded_size = GET_MODE_SIZE (mode);
|
unsigned int rounded_size = GET_MODE_SIZE (mode);
|
|
|
#ifdef PUSH_ROUNDING
|
#ifdef PUSH_ROUNDING
|
rounded_size = PUSH_ROUNDING (rounded_size);
|
rounded_size = PUSH_ROUNDING (rounded_size);
|
#endif
|
#endif
|
|
|
if (!MEM_P (op))
|
if (!MEM_P (op))
|
return 0;
|
return 0;
|
|
|
if (mode != VOIDmode && GET_MODE (op) != mode)
|
if (mode != VOIDmode && GET_MODE (op) != mode)
|
return 0;
|
return 0;
|
|
|
op = XEXP (op, 0);
|
op = XEXP (op, 0);
|
|
|
if (rounded_size == GET_MODE_SIZE (mode))
|
if (rounded_size == GET_MODE_SIZE (mode))
|
{
|
{
|
if (GET_CODE (op) != STACK_PUSH_CODE)
|
if (GET_CODE (op) != STACK_PUSH_CODE)
|
return 0;
|
return 0;
|
}
|
}
|
else
|
else
|
{
|
{
|
if (GET_CODE (op) != PRE_MODIFY
|
if (GET_CODE (op) != PRE_MODIFY
|
|| GET_CODE (XEXP (op, 1)) != PLUS
|
|| GET_CODE (XEXP (op, 1)) != PLUS
|
|| XEXP (XEXP (op, 1), 0) != XEXP (op, 0)
|
|| XEXP (XEXP (op, 1), 0) != XEXP (op, 0)
|
|| GET_CODE (XEXP (XEXP (op, 1), 1)) != CONST_INT
|
|| GET_CODE (XEXP (XEXP (op, 1), 1)) != CONST_INT
|
#ifdef STACK_GROWS_DOWNWARD
|
#ifdef STACK_GROWS_DOWNWARD
|
|| INTVAL (XEXP (XEXP (op, 1), 1)) != - (int) rounded_size
|
|| INTVAL (XEXP (XEXP (op, 1), 1)) != - (int) rounded_size
|
#else
|
#else
|
|| INTVAL (XEXP (XEXP (op, 1), 1)) != (int) rounded_size
|
|| INTVAL (XEXP (XEXP (op, 1), 1)) != (int) rounded_size
|
#endif
|
#endif
|
)
|
)
|
return 0;
|
return 0;
|
}
|
}
|
|
|
return XEXP (op, 0) == stack_pointer_rtx;
|
return XEXP (op, 0) == stack_pointer_rtx;
|
}
|
}
|
|
|
/* Return 1 if OP is a valid operand that stands for popping a
|
/* Return 1 if OP is a valid operand that stands for popping a
|
value of mode MODE off the stack.
|
value of mode MODE off the stack.
|
|
|
The main use of this function is as a predicate in match_operand
|
The main use of this function is as a predicate in match_operand
|
expressions in the machine description. */
|
expressions in the machine description. */
|
|
|
int
|
int
|
pop_operand (rtx op, enum machine_mode mode)
|
pop_operand (rtx op, enum machine_mode mode)
|
{
|
{
|
if (!MEM_P (op))
|
if (!MEM_P (op))
|
return 0;
|
return 0;
|
|
|
if (mode != VOIDmode && GET_MODE (op) != mode)
|
if (mode != VOIDmode && GET_MODE (op) != mode)
|
return 0;
|
return 0;
|
|
|
op = XEXP (op, 0);
|
op = XEXP (op, 0);
|
|
|
if (GET_CODE (op) != STACK_POP_CODE)
|
if (GET_CODE (op) != STACK_POP_CODE)
|
return 0;
|
return 0;
|
|
|
return XEXP (op, 0) == stack_pointer_rtx;
|
return XEXP (op, 0) == stack_pointer_rtx;
|
}
|
}
|
|
|
/* Return 1 if ADDR is a valid memory address for mode MODE. */
|
/* Return 1 if ADDR is a valid memory address for mode MODE. */
|
|
|
int
|
int
|
memory_address_p (enum machine_mode mode ATTRIBUTE_UNUSED, rtx addr)
|
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;
|
}
|
}
|
|
|
/* Return 1 if OP is a valid memory reference with mode MODE,
|
/* Return 1 if OP is a valid memory reference with mode MODE,
|
including a valid address.
|
including a valid address.
|
|
|
The main use of this function is as a predicate in match_operand
|
The main use of this function is as a predicate in match_operand
|
expressions in the machine description. */
|
expressions in the machine description. */
|
|
|
int
|
int
|
memory_operand (rtx op, enum machine_mode mode)
|
memory_operand (rtx op, enum machine_mode mode)
|
{
|
{
|
rtx inner;
|
rtx inner;
|
|
|
if (! reload_completed)
|
if (! reload_completed)
|
/* Note that no SUBREG is a memory operand before end of reload pass,
|
/* Note that no SUBREG is a memory operand before end of reload pass,
|
because (SUBREG (MEM...)) forces reloading into a register. */
|
because (SUBREG (MEM...)) forces reloading into a register. */
|
return MEM_P (op) && general_operand (op, mode);
|
return MEM_P (op) && general_operand (op, mode);
|
|
|
if (mode != VOIDmode && GET_MODE (op) != mode)
|
if (mode != VOIDmode && GET_MODE (op) != mode)
|
return 0;
|
return 0;
|
|
|
inner = op;
|
inner = op;
|
if (GET_CODE (inner) == SUBREG)
|
if (GET_CODE (inner) == SUBREG)
|
inner = SUBREG_REG (inner);
|
inner = SUBREG_REG (inner);
|
|
|
return (MEM_P (inner) && general_operand (op, mode));
|
return (MEM_P (inner) && general_operand (op, mode));
|
}
|
}
|
|
|
/* Return 1 if OP is a valid indirect memory reference with mode MODE;
|
/* Return 1 if OP is a valid indirect memory reference with mode MODE;
|
that is, a memory reference whose address is a general_operand. */
|
that is, a memory reference whose address is a general_operand. */
|
|
|
int
|
int
|
indirect_operand (rtx op, enum machine_mode mode)
|
indirect_operand (rtx op, enum machine_mode mode)
|
{
|
{
|
/* Before reload, a SUBREG isn't in memory (see memory_operand, above). */
|
/* Before reload, a SUBREG isn't in memory (see memory_operand, above). */
|
if (! reload_completed
|
if (! reload_completed
|
&& GET_CODE (op) == SUBREG && MEM_P (SUBREG_REG (op)))
|
&& GET_CODE (op) == SUBREG && MEM_P (SUBREG_REG (op)))
|
{
|
{
|
int offset = SUBREG_BYTE (op);
|
int offset = SUBREG_BYTE (op);
|
rtx inner = SUBREG_REG (op);
|
rtx inner = SUBREG_REG (op);
|
|
|
if (mode != VOIDmode && GET_MODE (op) != mode)
|
if (mode != VOIDmode && GET_MODE (op) != mode)
|
return 0;
|
return 0;
|
|
|
/* The only way that we can have a general_operand as the resulting
|
/* The only way that we can have a general_operand as the resulting
|
address is if OFFSET is zero and the address already is an operand
|
address is if OFFSET is zero and the address already is an operand
|
or if the address is (plus Y (const_int -OFFSET)) and Y is an
|
or if the address is (plus Y (const_int -OFFSET)) and Y is an
|
operand. */
|
operand. */
|
|
|
return ((offset == 0 && general_operand (XEXP (inner, 0), Pmode))
|
return ((offset == 0 && general_operand (XEXP (inner, 0), Pmode))
|
|| (GET_CODE (XEXP (inner, 0)) == PLUS
|
|| (GET_CODE (XEXP (inner, 0)) == PLUS
|
&& GET_CODE (XEXP (XEXP (inner, 0), 1)) == CONST_INT
|
&& GET_CODE (XEXP (XEXP (inner, 0), 1)) == CONST_INT
|
&& INTVAL (XEXP (XEXP (inner, 0), 1)) == -offset
|
&& INTVAL (XEXP (XEXP (inner, 0), 1)) == -offset
|
&& general_operand (XEXP (XEXP (inner, 0), 0), Pmode)));
|
&& general_operand (XEXP (XEXP (inner, 0), 0), Pmode)));
|
}
|
}
|
|
|
return (MEM_P (op)
|
return (MEM_P (op)
|
&& memory_operand (op, mode)
|
&& memory_operand (op, mode)
|
&& general_operand (XEXP (op, 0), Pmode));
|
&& general_operand (XEXP (op, 0), Pmode));
|
}
|
}
|
|
|
/* Return 1 if this is a comparison operator. This allows the use of
|
/* Return 1 if this is a comparison operator. This allows the use of
|
MATCH_OPERATOR to recognize all the branch insns. */
|
MATCH_OPERATOR to recognize all the branch insns. */
|
|
|
int
|
int
|
comparison_operator (rtx op, enum machine_mode mode)
|
comparison_operator (rtx op, enum machine_mode mode)
|
{
|
{
|
return ((mode == VOIDmode || GET_MODE (op) == mode)
|
return ((mode == VOIDmode || GET_MODE (op) == mode)
|
&& COMPARISON_P (op));
|
&& COMPARISON_P (op));
|
}
|
}
|
|
|
/* If BODY is an insn body that uses ASM_OPERANDS,
|
/* If BODY is an insn body that uses ASM_OPERANDS,
|
return the number of operands (both input and output) in the insn.
|
return the number of operands (both input and output) in the insn.
|
Otherwise return -1. */
|
Otherwise return -1. */
|
|
|
int
|
int
|
asm_noperands (rtx body)
|
asm_noperands (rtx body)
|
{
|
{
|
switch (GET_CODE (body))
|
switch (GET_CODE (body))
|
{
|
{
|
case ASM_OPERANDS:
|
case ASM_OPERANDS:
|
/* No output operands: return number of input operands. */
|
/* No output operands: return number of input operands. */
|
return ASM_OPERANDS_INPUT_LENGTH (body);
|
return ASM_OPERANDS_INPUT_LENGTH (body);
|
case SET:
|
case SET:
|
if (GET_CODE (SET_SRC (body)) == ASM_OPERANDS)
|
if (GET_CODE (SET_SRC (body)) == ASM_OPERANDS)
|
/* Single output operand: BODY is (set OUTPUT (asm_operands ...)). */
|
/* Single output operand: BODY is (set OUTPUT (asm_operands ...)). */
|
return ASM_OPERANDS_INPUT_LENGTH (SET_SRC (body)) + 1;
|
return ASM_OPERANDS_INPUT_LENGTH (SET_SRC (body)) + 1;
|
else
|
else
|
return -1;
|
return -1;
|
case PARALLEL:
|
case PARALLEL:
|
if (GET_CODE (XVECEXP (body, 0, 0)) == SET
|
if (GET_CODE (XVECEXP (body, 0, 0)) == SET
|
&& GET_CODE (SET_SRC (XVECEXP (body, 0, 0))) == ASM_OPERANDS)
|
&& GET_CODE (SET_SRC (XVECEXP (body, 0, 0))) == ASM_OPERANDS)
|
{
|
{
|
/* Multiple output operands, or 1 output plus some clobbers:
|
/* Multiple output operands, or 1 output plus some clobbers:
|
body is [(set OUTPUT (asm_operands ...))... (clobber (reg ...))...]. */
|
body is [(set OUTPUT (asm_operands ...))... (clobber (reg ...))...]. */
|
int i;
|
int i;
|
int n_sets;
|
int n_sets;
|
|
|
/* Count backwards through CLOBBERs to determine number of SETs. */
|
/* Count backwards through CLOBBERs to determine number of SETs. */
|
for (i = XVECLEN (body, 0); i > 0; i--)
|
for (i = XVECLEN (body, 0); i > 0; i--)
|
{
|
{
|
if (GET_CODE (XVECEXP (body, 0, i - 1)) == SET)
|
if (GET_CODE (XVECEXP (body, 0, i - 1)) == SET)
|
break;
|
break;
|
if (GET_CODE (XVECEXP (body, 0, i - 1)) != CLOBBER)
|
if (GET_CODE (XVECEXP (body, 0, i - 1)) != CLOBBER)
|
return -1;
|
return -1;
|
}
|
}
|
|
|
/* N_SETS is now number of output operands. */
|
/* N_SETS is now number of output operands. */
|
n_sets = i;
|
n_sets = i;
|
|
|
/* Verify that all the SETs we have
|
/* Verify that all the SETs we have
|
came from a single original asm_operands insn
|
came from a single original asm_operands insn
|
(so that invalid combinations are blocked). */
|
(so that invalid combinations are blocked). */
|
for (i = 0; i < n_sets; i++)
|
for (i = 0; i < n_sets; i++)
|
{
|
{
|
rtx elt = XVECEXP (body, 0, i);
|
rtx elt = XVECEXP (body, 0, i);
|
if (GET_CODE (elt) != SET)
|
if (GET_CODE (elt) != SET)
|
return -1;
|
return -1;
|
if (GET_CODE (SET_SRC (elt)) != ASM_OPERANDS)
|
if (GET_CODE (SET_SRC (elt)) != ASM_OPERANDS)
|
return -1;
|
return -1;
|
/* If these ASM_OPERANDS rtx's came from different original insns
|
/* If these ASM_OPERANDS rtx's came from different original insns
|
then they aren't allowed together. */
|
then they aren't allowed together. */
|
if (ASM_OPERANDS_INPUT_VEC (SET_SRC (elt))
|
if (ASM_OPERANDS_INPUT_VEC (SET_SRC (elt))
|
!= ASM_OPERANDS_INPUT_VEC (SET_SRC (XVECEXP (body, 0, 0))))
|
!= ASM_OPERANDS_INPUT_VEC (SET_SRC (XVECEXP (body, 0, 0))))
|
return -1;
|
return -1;
|
}
|
}
|
return (ASM_OPERANDS_INPUT_LENGTH (SET_SRC (XVECEXP (body, 0, 0)))
|
return (ASM_OPERANDS_INPUT_LENGTH (SET_SRC (XVECEXP (body, 0, 0)))
|
+ n_sets);
|
+ n_sets);
|
}
|
}
|
else if (GET_CODE (XVECEXP (body, 0, 0)) == ASM_OPERANDS)
|
else if (GET_CODE (XVECEXP (body, 0, 0)) == ASM_OPERANDS)
|
{
|
{
|
/* 0 outputs, but some clobbers:
|
/* 0 outputs, but some clobbers:
|
body is [(asm_operands ...) (clobber (reg ...))...]. */
|
body is [(asm_operands ...) (clobber (reg ...))...]. */
|
int i;
|
int i;
|
|
|
/* Make sure all the other parallel things really are clobbers. */
|
/* Make sure all the other parallel things really are clobbers. */
|
for (i = XVECLEN (body, 0) - 1; i > 0; i--)
|
for (i = XVECLEN (body, 0) - 1; i > 0; i--)
|
if (GET_CODE (XVECEXP (body, 0, i)) != CLOBBER)
|
if (GET_CODE (XVECEXP (body, 0, i)) != CLOBBER)
|
return -1;
|
return -1;
|
|
|
return ASM_OPERANDS_INPUT_LENGTH (XVECEXP (body, 0, 0));
|
return ASM_OPERANDS_INPUT_LENGTH (XVECEXP (body, 0, 0));
|
}
|
}
|
else
|
else
|
return -1;
|
return -1;
|
default:
|
default:
|
return -1;
|
return -1;
|
}
|
}
|
}
|
}
|
|
|
/* Assuming BODY is an insn body that uses ASM_OPERANDS,
|
/* Assuming BODY is an insn body that uses ASM_OPERANDS,
|
copy its operands (both input and output) into the vector OPERANDS,
|
copy its operands (both input and output) into the vector OPERANDS,
|
the locations of the operands within the insn into the vector OPERAND_LOCS,
|
the locations of the operands within the insn into the vector OPERAND_LOCS,
|
and the constraints for the operands into CONSTRAINTS.
|
and the constraints for the operands into CONSTRAINTS.
|
Write the modes of the operands into MODES.
|
Write the modes of the operands into MODES.
|
Return the assembler-template.
|
Return the assembler-template.
|
|
|
If MODES, OPERAND_LOCS, CONSTRAINTS or OPERANDS is 0,
|
If MODES, OPERAND_LOCS, CONSTRAINTS or OPERANDS is 0,
|
we don't store that info. */
|
we don't store that info. */
|
|
|
const char *
|
const char *
|
decode_asm_operands (rtx body, rtx *operands, rtx **operand_locs,
|
decode_asm_operands (rtx body, rtx *operands, rtx **operand_locs,
|
const char **constraints, enum machine_mode *modes)
|
const char **constraints, enum machine_mode *modes)
|
{
|
{
|
int i;
|
int i;
|
int noperands;
|
int noperands;
|
const char *template = 0;
|
const char *template = 0;
|
|
|
if (GET_CODE (body) == SET && GET_CODE (SET_SRC (body)) == ASM_OPERANDS)
|
if (GET_CODE (body) == SET && GET_CODE (SET_SRC (body)) == ASM_OPERANDS)
|
{
|
{
|
rtx asmop = SET_SRC (body);
|
rtx asmop = SET_SRC (body);
|
/* Single output operand: BODY is (set OUTPUT (asm_operands ....)). */
|
/* Single output operand: BODY is (set OUTPUT (asm_operands ....)). */
|
|
|
noperands = ASM_OPERANDS_INPUT_LENGTH (asmop) + 1;
|
noperands = ASM_OPERANDS_INPUT_LENGTH (asmop) + 1;
|
|
|
for (i = 1; i < noperands; i++)
|
for (i = 1; i < noperands; i++)
|
{
|
{
|
if (operand_locs)
|
if (operand_locs)
|
operand_locs[i] = &ASM_OPERANDS_INPUT (asmop, i - 1);
|
operand_locs[i] = &ASM_OPERANDS_INPUT (asmop, i - 1);
|
if (operands)
|
if (operands)
|
operands[i] = ASM_OPERANDS_INPUT (asmop, i - 1);
|
operands[i] = ASM_OPERANDS_INPUT (asmop, i - 1);
|
if (constraints)
|
if (constraints)
|
constraints[i] = ASM_OPERANDS_INPUT_CONSTRAINT (asmop, i - 1);
|
constraints[i] = ASM_OPERANDS_INPUT_CONSTRAINT (asmop, i - 1);
|
if (modes)
|
if (modes)
|
modes[i] = ASM_OPERANDS_INPUT_MODE (asmop, i - 1);
|
modes[i] = ASM_OPERANDS_INPUT_MODE (asmop, i - 1);
|
}
|
}
|
|
|
/* The output is in the SET.
|
/* The output is in the SET.
|
Its constraint is in the ASM_OPERANDS itself. */
|
Its constraint is in the ASM_OPERANDS itself. */
|
if (operands)
|
if (operands)
|
operands[0] = SET_DEST (body);
|
operands[0] = SET_DEST (body);
|
if (operand_locs)
|
if (operand_locs)
|
operand_locs[0] = &SET_DEST (body);
|
operand_locs[0] = &SET_DEST (body);
|
if (constraints)
|
if (constraints)
|
constraints[0] = ASM_OPERANDS_OUTPUT_CONSTRAINT (asmop);
|
constraints[0] = ASM_OPERANDS_OUTPUT_CONSTRAINT (asmop);
|
if (modes)
|
if (modes)
|
modes[0] = GET_MODE (SET_DEST (body));
|
modes[0] = GET_MODE (SET_DEST (body));
|
template = ASM_OPERANDS_TEMPLATE (asmop);
|
template = ASM_OPERANDS_TEMPLATE (asmop);
|
}
|
}
|
else if (GET_CODE (body) == ASM_OPERANDS)
|
else if (GET_CODE (body) == ASM_OPERANDS)
|
{
|
{
|
rtx asmop = body;
|
rtx asmop = body;
|
/* No output operands: BODY is (asm_operands ....). */
|
/* No output operands: BODY is (asm_operands ....). */
|
|
|
noperands = ASM_OPERANDS_INPUT_LENGTH (asmop);
|
noperands = ASM_OPERANDS_INPUT_LENGTH (asmop);
|
|
|
/* The input operands are found in the 1st element vector. */
|
/* The input operands are found in the 1st element vector. */
|
/* Constraints for inputs are in the 2nd element vector. */
|
/* Constraints for inputs are in the 2nd element vector. */
|
for (i = 0; i < noperands; i++)
|
for (i = 0; i < noperands; i++)
|
{
|
{
|
if (operand_locs)
|
if (operand_locs)
|
operand_locs[i] = &ASM_OPERANDS_INPUT (asmop, i);
|
operand_locs[i] = &ASM_OPERANDS_INPUT (asmop, i);
|
if (operands)
|
if (operands)
|
operands[i] = ASM_OPERANDS_INPUT (asmop, i);
|
operands[i] = ASM_OPERANDS_INPUT (asmop, i);
|
if (constraints)
|
if (constraints)
|
constraints[i] = ASM_OPERANDS_INPUT_CONSTRAINT (asmop, i);
|
constraints[i] = ASM_OPERANDS_INPUT_CONSTRAINT (asmop, i);
|
if (modes)
|
if (modes)
|
modes[i] = ASM_OPERANDS_INPUT_MODE (asmop, i);
|
modes[i] = ASM_OPERANDS_INPUT_MODE (asmop, i);
|
}
|
}
|
template = ASM_OPERANDS_TEMPLATE (asmop);
|
template = ASM_OPERANDS_TEMPLATE (asmop);
|
}
|
}
|
else if (GET_CODE (body) == PARALLEL
|
else if (GET_CODE (body) == PARALLEL
|
&& GET_CODE (XVECEXP (body, 0, 0)) == SET
|
&& GET_CODE (XVECEXP (body, 0, 0)) == SET
|
&& GET_CODE (SET_SRC (XVECEXP (body, 0, 0))) == ASM_OPERANDS)
|
&& GET_CODE (SET_SRC (XVECEXP (body, 0, 0))) == ASM_OPERANDS)
|
{
|
{
|
rtx asmop = SET_SRC (XVECEXP (body, 0, 0));
|
rtx asmop = SET_SRC (XVECEXP (body, 0, 0));
|
int nparallel = XVECLEN (body, 0); /* Includes CLOBBERs. */
|
int nparallel = XVECLEN (body, 0); /* Includes CLOBBERs. */
|
int nin = ASM_OPERANDS_INPUT_LENGTH (asmop);
|
int nin = ASM_OPERANDS_INPUT_LENGTH (asmop);
|
int nout = 0; /* Does not include CLOBBERs. */
|
int nout = 0; /* Does not include CLOBBERs. */
|
|
|
/* At least one output, plus some CLOBBERs. */
|
/* At least one output, plus some CLOBBERs. */
|
|
|
/* The outputs are in the SETs.
|
/* The outputs are in the SETs.
|
Their constraints are in the ASM_OPERANDS itself. */
|
Their constraints are in the ASM_OPERANDS itself. */
|
for (i = 0; i < nparallel; i++)
|
for (i = 0; i < nparallel; i++)
|
{
|
{
|
if (GET_CODE (XVECEXP (body, 0, i)) == CLOBBER)
|
if (GET_CODE (XVECEXP (body, 0, i)) == CLOBBER)
|
break; /* Past last SET */
|
break; /* Past last SET */
|
|
|
if (operands)
|
if (operands)
|
operands[i] = SET_DEST (XVECEXP (body, 0, i));
|
operands[i] = SET_DEST (XVECEXP (body, 0, i));
|
if (operand_locs)
|
if (operand_locs)
|
operand_locs[i] = &SET_DEST (XVECEXP (body, 0, i));
|
operand_locs[i] = &SET_DEST (XVECEXP (body, 0, i));
|
if (constraints)
|
if (constraints)
|
constraints[i] = XSTR (SET_SRC (XVECEXP (body, 0, i)), 1);
|
constraints[i] = XSTR (SET_SRC (XVECEXP (body, 0, i)), 1);
|
if (modes)
|
if (modes)
|
modes[i] = GET_MODE (SET_DEST (XVECEXP (body, 0, i)));
|
modes[i] = GET_MODE (SET_DEST (XVECEXP (body, 0, i)));
|
nout++;
|
nout++;
|
}
|
}
|
|
|
for (i = 0; i < nin; i++)
|
for (i = 0; i < nin; i++)
|
{
|
{
|
if (operand_locs)
|
if (operand_locs)
|
operand_locs[i + nout] = &ASM_OPERANDS_INPUT (asmop, i);
|
operand_locs[i + nout] = &ASM_OPERANDS_INPUT (asmop, i);
|
if (operands)
|
if (operands)
|
operands[i + nout] = ASM_OPERANDS_INPUT (asmop, i);
|
operands[i + nout] = ASM_OPERANDS_INPUT (asmop, i);
|
if (constraints)
|
if (constraints)
|
constraints[i + nout] = ASM_OPERANDS_INPUT_CONSTRAINT (asmop, i);
|
constraints[i + nout] = ASM_OPERANDS_INPUT_CONSTRAINT (asmop, i);
|
if (modes)
|
if (modes)
|
modes[i + nout] = ASM_OPERANDS_INPUT_MODE (asmop, i);
|
modes[i + nout] = ASM_OPERANDS_INPUT_MODE (asmop, i);
|
}
|
}
|
|
|
template = ASM_OPERANDS_TEMPLATE (asmop);
|
template = ASM_OPERANDS_TEMPLATE (asmop);
|
}
|
}
|
else if (GET_CODE (body) == PARALLEL
|
else if (GET_CODE (body) == PARALLEL
|
&& GET_CODE (XVECEXP (body, 0, 0)) == ASM_OPERANDS)
|
&& GET_CODE (XVECEXP (body, 0, 0)) == ASM_OPERANDS)
|
{
|
{
|
/* No outputs, but some CLOBBERs. */
|
/* No outputs, but some CLOBBERs. */
|
|
|
rtx asmop = XVECEXP (body, 0, 0);
|
rtx asmop = XVECEXP (body, 0, 0);
|
int nin = ASM_OPERANDS_INPUT_LENGTH (asmop);
|
int nin = ASM_OPERANDS_INPUT_LENGTH (asmop);
|
|
|
for (i = 0; i < nin; i++)
|
for (i = 0; i < nin; i++)
|
{
|
{
|
if (operand_locs)
|
if (operand_locs)
|
operand_locs[i] = &ASM_OPERANDS_INPUT (asmop, i);
|
operand_locs[i] = &ASM_OPERANDS_INPUT (asmop, i);
|
if (operands)
|
if (operands)
|
operands[i] = ASM_OPERANDS_INPUT (asmop, i);
|
operands[i] = ASM_OPERANDS_INPUT (asmop, i);
|
if (constraints)
|
if (constraints)
|
constraints[i] = ASM_OPERANDS_INPUT_CONSTRAINT (asmop, i);
|
constraints[i] = ASM_OPERANDS_INPUT_CONSTRAINT (asmop, i);
|
if (modes)
|
if (modes)
|
modes[i] = ASM_OPERANDS_INPUT_MODE (asmop, i);
|
modes[i] = ASM_OPERANDS_INPUT_MODE (asmop, i);
|
}
|
}
|
|
|
template = ASM_OPERANDS_TEMPLATE (asmop);
|
template = ASM_OPERANDS_TEMPLATE (asmop);
|
}
|
}
|
|
|
return template;
|
return template;
|
}
|
}
|
|
|
/* Check if an asm_operand matches its constraints.
|
/* Check if an asm_operand matches its constraints.
|
Return > 0 if ok, = 0 if bad, < 0 if inconclusive. */
|
Return > 0 if ok, = 0 if bad, < 0 if inconclusive. */
|
|
|
int
|
int
|
asm_operand_ok (rtx op, const char *constraint)
|
asm_operand_ok (rtx op, const char *constraint)
|
{
|
{
|
int result = 0;
|
int result = 0;
|
|
|
/* Use constrain_operands after reload. */
|
/* Use constrain_operands after reload. */
|
gcc_assert (!reload_completed);
|
gcc_assert (!reload_completed);
|
|
|
while (*constraint)
|
while (*constraint)
|
{
|
{
|
char c = *constraint;
|
char c = *constraint;
|
int len;
|
int len;
|
switch (c)
|
switch (c)
|
{
|
{
|
case ',':
|
case ',':
|
constraint++;
|
constraint++;
|
continue;
|
continue;
|
case '=':
|
case '=':
|
case '+':
|
case '+':
|
case '*':
|
case '*':
|
case '%':
|
case '%':
|
case '!':
|
case '!':
|
case '#':
|
case '#':
|
case '&':
|
case '&':
|
case '?':
|
case '?':
|
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':
|
/* For best results, our caller should have given us the
|
/* For best results, our caller should have given us the
|
proper matching constraint, but we can't actually fail
|
proper matching constraint, but we can't actually fail
|
the check if they didn't. Indicate that results are
|
the check if they didn't. Indicate that results are
|
inconclusive. */
|
inconclusive. */
|
do
|
do
|
constraint++;
|
constraint++;
|
while (ISDIGIT (*constraint));
|
while (ISDIGIT (*constraint));
|
if (! result)
|
if (! result)
|
result = -1;
|
result = -1;
|
continue;
|
continue;
|
|
|
case 'p':
|
case 'p':
|
if (address_operand (op, VOIDmode))
|
if (address_operand (op, VOIDmode))
|
result = 1;
|
result = 1;
|
break;
|
break;
|
|
|
case 'm':
|
case 'm':
|
case 'V': /* non-offsettable */
|
case 'V': /* non-offsettable */
|
if (memory_operand (op, VOIDmode))
|
if (memory_operand (op, VOIDmode))
|
result = 1;
|
result = 1;
|
break;
|
break;
|
|
|
case 'o': /* offsettable */
|
case 'o': /* offsettable */
|
if (offsettable_nonstrict_memref_p (op))
|
if (offsettable_nonstrict_memref_p (op))
|
result = 1;
|
result = 1;
|
break;
|
break;
|
|
|
case '<':
|
case '<':
|
/* ??? Before flow, auto inc/dec insns are not supposed to exist,
|
/* ??? Before flow, auto inc/dec insns are not supposed to exist,
|
excepting those that expand_call created. Further, on some
|
excepting those that expand_call created. Further, on some
|
machines which do not have generalized auto inc/dec, an inc/dec
|
machines which do not have generalized auto inc/dec, an inc/dec
|
is not a memory_operand.
|
is not a memory_operand.
|
|
|
Match any memory and hope things are resolved after reload. */
|
Match any memory and hope things are resolved after reload. */
|
|
|
if (MEM_P (op)
|
if (MEM_P (op)
|
&& (1
|
&& (1
|
|| GET_CODE (XEXP (op, 0)) == PRE_DEC
|
|| GET_CODE (XEXP (op, 0)) == PRE_DEC
|
|| GET_CODE (XEXP (op, 0)) == POST_DEC))
|
|| GET_CODE (XEXP (op, 0)) == POST_DEC))
|
result = 1;
|
result = 1;
|
break;
|
break;
|
|
|
case '>':
|
case '>':
|
if (MEM_P (op)
|
if (MEM_P (op)
|
&& (1
|
&& (1
|
|| GET_CODE (XEXP (op, 0)) == PRE_INC
|
|| GET_CODE (XEXP (op, 0)) == PRE_INC
|
|| GET_CODE (XEXP (op, 0)) == POST_INC))
|
|| GET_CODE (XEXP (op, 0)) == POST_INC))
|
result = 1;
|
result = 1;
|
break;
|
break;
|
|
|
case 'E':
|
case 'E':
|
case 'F':
|
case 'F':
|
if (GET_CODE (op) == CONST_DOUBLE
|
if (GET_CODE (op) == CONST_DOUBLE
|
|| (GET_CODE (op) == CONST_VECTOR
|
|| (GET_CODE (op) == CONST_VECTOR
|
&& GET_MODE_CLASS (GET_MODE (op)) == MODE_VECTOR_FLOAT))
|
&& GET_MODE_CLASS (GET_MODE (op)) == MODE_VECTOR_FLOAT))
|
result = 1;
|
result = 1;
|
break;
|
break;
|
|
|
case 'G':
|
case 'G':
|
if (GET_CODE (op) == CONST_DOUBLE
|
if (GET_CODE (op) == CONST_DOUBLE
|
&& CONST_DOUBLE_OK_FOR_CONSTRAINT_P (op, 'G', constraint))
|
&& CONST_DOUBLE_OK_FOR_CONSTRAINT_P (op, 'G', constraint))
|
result = 1;
|
result = 1;
|
break;
|
break;
|
case 'H':
|
case 'H':
|
if (GET_CODE (op) == CONST_DOUBLE
|
if (GET_CODE (op) == CONST_DOUBLE
|
&& CONST_DOUBLE_OK_FOR_CONSTRAINT_P (op, 'H', constraint))
|
&& CONST_DOUBLE_OK_FOR_CONSTRAINT_P (op, 'H', constraint))
|
result = 1;
|
result = 1;
|
break;
|
break;
|
|
|
case 's':
|
case 's':
|
if (GET_CODE (op) == CONST_INT
|
if (GET_CODE (op) == CONST_INT
|
|| (GET_CODE (op) == CONST_DOUBLE
|
|| (GET_CODE (op) == CONST_DOUBLE
|
&& GET_MODE (op) == VOIDmode))
|
&& GET_MODE (op) == VOIDmode))
|
break;
|
break;
|
/* Fall through. */
|
/* Fall through. */
|
|
|
case 'i':
|
case 'i':
|
if (CONSTANT_P (op) && (! flag_pic || LEGITIMATE_PIC_OPERAND_P (op)))
|
if (CONSTANT_P (op) && (! flag_pic || LEGITIMATE_PIC_OPERAND_P (op)))
|
result = 1;
|
result = 1;
|
break;
|
break;
|
|
|
case 'n':
|
case 'n':
|
if (GET_CODE (op) == CONST_INT
|
if (GET_CODE (op) == CONST_INT
|
|| (GET_CODE (op) == CONST_DOUBLE
|
|| (GET_CODE (op) == CONST_DOUBLE
|
&& GET_MODE (op) == VOIDmode))
|
&& GET_MODE (op) == VOIDmode))
|
result = 1;
|
result = 1;
|
break;
|
break;
|
|
|
case 'I':
|
case 'I':
|
if (GET_CODE (op) == CONST_INT
|
if (GET_CODE (op) == CONST_INT
|
&& CONST_OK_FOR_CONSTRAINT_P (INTVAL (op), 'I', constraint))
|
&& CONST_OK_FOR_CONSTRAINT_P (INTVAL (op), 'I', constraint))
|
result = 1;
|
result = 1;
|
break;
|
break;
|
case 'J':
|
case 'J':
|
if (GET_CODE (op) == CONST_INT
|
if (GET_CODE (op) == CONST_INT
|
&& CONST_OK_FOR_CONSTRAINT_P (INTVAL (op), 'J', constraint))
|
&& CONST_OK_FOR_CONSTRAINT_P (INTVAL (op), 'J', constraint))
|
result = 1;
|
result = 1;
|
break;
|
break;
|
case 'K':
|
case 'K':
|
if (GET_CODE (op) == CONST_INT
|
if (GET_CODE (op) == CONST_INT
|
&& CONST_OK_FOR_CONSTRAINT_P (INTVAL (op), 'K', constraint))
|
&& CONST_OK_FOR_CONSTRAINT_P (INTVAL (op), 'K', constraint))
|
result = 1;
|
result = 1;
|
break;
|
break;
|
case 'L':
|
case 'L':
|
if (GET_CODE (op) == CONST_INT
|
if (GET_CODE (op) == CONST_INT
|
&& CONST_OK_FOR_CONSTRAINT_P (INTVAL (op), 'L', constraint))
|
&& CONST_OK_FOR_CONSTRAINT_P (INTVAL (op), 'L', constraint))
|
result = 1;
|
result = 1;
|
break;
|
break;
|
case 'M':
|
case 'M':
|
if (GET_CODE (op) == CONST_INT
|
if (GET_CODE (op) == CONST_INT
|
&& CONST_OK_FOR_CONSTRAINT_P (INTVAL (op), 'M', constraint))
|
&& CONST_OK_FOR_CONSTRAINT_P (INTVAL (op), 'M', constraint))
|
result = 1;
|
result = 1;
|
break;
|
break;
|
case 'N':
|
case 'N':
|
if (GET_CODE (op) == CONST_INT
|
if (GET_CODE (op) == CONST_INT
|
&& CONST_OK_FOR_CONSTRAINT_P (INTVAL (op), 'N', constraint))
|
&& CONST_OK_FOR_CONSTRAINT_P (INTVAL (op), 'N', constraint))
|
result = 1;
|
result = 1;
|
break;
|
break;
|
case 'O':
|
case 'O':
|
if (GET_CODE (op) == CONST_INT
|
if (GET_CODE (op) == CONST_INT
|
&& CONST_OK_FOR_CONSTRAINT_P (INTVAL (op), 'O', constraint))
|
&& CONST_OK_FOR_CONSTRAINT_P (INTVAL (op), 'O', constraint))
|
result = 1;
|
result = 1;
|
break;
|
break;
|
case 'P':
|
case 'P':
|
if (GET_CODE (op) == CONST_INT
|
if (GET_CODE (op) == CONST_INT
|
&& CONST_OK_FOR_CONSTRAINT_P (INTVAL (op), 'P', constraint))
|
&& CONST_OK_FOR_CONSTRAINT_P (INTVAL (op), 'P', constraint))
|
result = 1;
|
result = 1;
|
break;
|
break;
|
|
|
case 'X':
|
case 'X':
|
result = 1;
|
result = 1;
|
break;
|
break;
|
|
|
case 'g':
|
case 'g':
|
if (general_operand (op, VOIDmode))
|
if (general_operand (op, VOIDmode))
|
result = 1;
|
result = 1;
|
break;
|
break;
|
|
|
default:
|
default:
|
/* For all other letters, we first check for a register class,
|
/* For all other letters, we first check for a register class,
|
otherwise it is an EXTRA_CONSTRAINT. */
|
otherwise it is an EXTRA_CONSTRAINT. */
|
if (REG_CLASS_FROM_CONSTRAINT (c, constraint) != NO_REGS)
|
if (REG_CLASS_FROM_CONSTRAINT (c, constraint) != NO_REGS)
|
{
|
{
|
case 'r':
|
case 'r':
|
if (GET_MODE (op) == BLKmode)
|
if (GET_MODE (op) == BLKmode)
|
break;
|
break;
|
if (register_operand (op, VOIDmode))
|
if (register_operand (op, VOIDmode))
|
result = 1;
|
result = 1;
|
}
|
}
|
#ifdef EXTRA_CONSTRAINT_STR
|
#ifdef EXTRA_CONSTRAINT_STR
|
else if (EXTRA_CONSTRAINT_STR (op, c, constraint))
|
else if (EXTRA_CONSTRAINT_STR (op, c, constraint))
|
result = 1;
|
result = 1;
|
else if (EXTRA_MEMORY_CONSTRAINT (c, constraint)
|
else if (EXTRA_MEMORY_CONSTRAINT (c, constraint)
|
/* Every memory operand can be reloaded to fit. */
|
/* Every memory operand can be reloaded to fit. */
|
&& memory_operand (op, VOIDmode))
|
&& memory_operand (op, VOIDmode))
|
result = 1;
|
result = 1;
|
else if (EXTRA_ADDRESS_CONSTRAINT (c, constraint)
|
else if (EXTRA_ADDRESS_CONSTRAINT (c, constraint)
|
/* Every address operand can be reloaded to fit. */
|
/* Every address operand can be reloaded to fit. */
|
&& address_operand (op, VOIDmode))
|
&& address_operand (op, VOIDmode))
|
result = 1;
|
result = 1;
|
#endif
|
#endif
|
break;
|
break;
|
}
|
}
|
len = CONSTRAINT_LEN (c, constraint);
|
len = CONSTRAINT_LEN (c, constraint);
|
do
|
do
|
constraint++;
|
constraint++;
|
while (--len && *constraint);
|
while (--len && *constraint);
|
if (len)
|
if (len)
|
return 0;
|
return 0;
|
}
|
}
|
|
|
return result;
|
return result;
|
}
|
}
|
|
|
/* Given an rtx *P, if it is a sum containing an integer constant term,
|
/* Given an rtx *P, if it is a sum containing an integer constant term,
|
return the location (type rtx *) of the pointer to that constant term.
|
return the location (type rtx *) of the pointer to that constant term.
|
Otherwise, return a null pointer. */
|
Otherwise, return a null pointer. */
|
|
|
rtx *
|
rtx *
|
find_constant_term_loc (rtx *p)
|
find_constant_term_loc (rtx *p)
|
{
|
{
|
rtx *tem;
|
rtx *tem;
|
enum rtx_code code = GET_CODE (*p);
|
enum rtx_code code = GET_CODE (*p);
|
|
|
/* If *P IS such a constant term, P is its location. */
|
/* If *P IS such a constant term, P is its location. */
|
|
|
if (code == CONST_INT || code == SYMBOL_REF || code == LABEL_REF
|
if (code == CONST_INT || code == SYMBOL_REF || code == LABEL_REF
|
|| code == CONST)
|
|| code == CONST)
|
return p;
|
return p;
|
|
|
/* Otherwise, if not a sum, it has no constant term. */
|
/* Otherwise, if not a sum, it has no constant term. */
|
|
|
if (GET_CODE (*p) != PLUS)
|
if (GET_CODE (*p) != PLUS)
|
return 0;
|
return 0;
|
|
|
/* If one of the summands is constant, return its location. */
|
/* If one of the summands is constant, return its location. */
|
|
|
if (XEXP (*p, 0) && CONSTANT_P (XEXP (*p, 0))
|
if (XEXP (*p, 0) && CONSTANT_P (XEXP (*p, 0))
|
&& XEXP (*p, 1) && CONSTANT_P (XEXP (*p, 1)))
|
&& XEXP (*p, 1) && CONSTANT_P (XEXP (*p, 1)))
|
return p;
|
return p;
|
|
|
/* Otherwise, check each summand for containing a constant term. */
|
/* Otherwise, check each summand for containing a constant term. */
|
|
|
if (XEXP (*p, 0) != 0)
|
if (XEXP (*p, 0) != 0)
|
{
|
{
|
tem = find_constant_term_loc (&XEXP (*p, 0));
|
tem = find_constant_term_loc (&XEXP (*p, 0));
|
if (tem != 0)
|
if (tem != 0)
|
return tem;
|
return tem;
|
}
|
}
|
|
|
if (XEXP (*p, 1) != 0)
|
if (XEXP (*p, 1) != 0)
|
{
|
{
|
tem = find_constant_term_loc (&XEXP (*p, 1));
|
tem = find_constant_term_loc (&XEXP (*p, 1));
|
if (tem != 0)
|
if (tem != 0)
|
return tem;
|
return tem;
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Return 1 if OP is a memory reference
|
/* Return 1 if OP is a memory reference
|
whose address contains no side effects
|
whose address contains no side effects
|
and remains valid after the addition
|
and remains valid after the addition
|
of a positive integer less than the
|
of a positive integer less than the
|
size of the object being referenced.
|
size of the object being referenced.
|
|
|
We assume that the original address is valid and do not check it.
|
We assume that the original address is valid and do not check it.
|
|
|
This uses strict_memory_address_p as a subroutine, so
|
This uses strict_memory_address_p as a subroutine, so
|
don't use it before reload. */
|
don't use it before reload. */
|
|
|
int
|
int
|
offsettable_memref_p (rtx op)
|
offsettable_memref_p (rtx op)
|
{
|
{
|
return ((MEM_P (op))
|
return ((MEM_P (op))
|
&& offsettable_address_p (1, GET_MODE (op), XEXP (op, 0)));
|
&& offsettable_address_p (1, GET_MODE (op), XEXP (op, 0)));
|
}
|
}
|
|
|
/* Similar, but don't require a strictly valid mem ref:
|
/* Similar, but don't require a strictly valid mem ref:
|
consider pseudo-regs valid as index or base regs. */
|
consider pseudo-regs valid as index or base regs. */
|
|
|
int
|
int
|
offsettable_nonstrict_memref_p (rtx op)
|
offsettable_nonstrict_memref_p (rtx op)
|
{
|
{
|
return ((MEM_P (op))
|
return ((MEM_P (op))
|
&& offsettable_address_p (0, GET_MODE (op), XEXP (op, 0)));
|
&& offsettable_address_p (0, GET_MODE (op), XEXP (op, 0)));
|
}
|
}
|
|
|
/* Return 1 if Y is a memory address which contains no side effects
|
/* Return 1 if Y is a memory address which contains no side effects
|
and would remain valid after the addition of a positive integer
|
and would remain valid after the addition of a positive integer
|
less than the size of that mode.
|
less than the size of that mode.
|
|
|
We assume that the original address is valid and do not check it.
|
We assume that the original address is valid and do not check it.
|
We do check that it is valid for narrower modes.
|
We do check that it is valid for narrower modes.
|
|
|
If STRICTP is nonzero, we require a strictly valid address,
|
If STRICTP is nonzero, we require a strictly valid address,
|
for the sake of use in reload.c. */
|
for the sake of use in reload.c. */
|
|
|
int
|
int
|
offsettable_address_p (int strictp, enum machine_mode mode, rtx y)
|
offsettable_address_p (int strictp, enum machine_mode mode, rtx y)
|
{
|
{
|
enum rtx_code ycode = GET_CODE (y);
|
enum rtx_code ycode = GET_CODE (y);
|
rtx z;
|
rtx z;
|
rtx y1 = y;
|
rtx y1 = y;
|
rtx *y2;
|
rtx *y2;
|
int (*addressp) (enum machine_mode, rtx) =
|
int (*addressp) (enum machine_mode, rtx) =
|
(strictp ? strict_memory_address_p : memory_address_p);
|
(strictp ? strict_memory_address_p : memory_address_p);
|
unsigned int mode_sz = GET_MODE_SIZE (mode);
|
unsigned int mode_sz = GET_MODE_SIZE (mode);
|
|
|
if (CONSTANT_ADDRESS_P (y))
|
if (CONSTANT_ADDRESS_P (y))
|
return 1;
|
return 1;
|
|
|
/* Adjusting an offsettable address involves changing to a narrower mode.
|
/* Adjusting an offsettable address involves changing to a narrower mode.
|
Make sure that's OK. */
|
Make sure that's OK. */
|
|
|
if (mode_dependent_address_p (y))
|
if (mode_dependent_address_p (y))
|
return 0;
|
return 0;
|
|
|
/* ??? How much offset does an offsettable BLKmode reference need?
|
/* ??? How much offset does an offsettable BLKmode reference need?
|
Clearly that depends on the situation in which it's being used.
|
Clearly that depends on the situation in which it's being used.
|
However, the current situation in which we test 0xffffffff is
|
However, the current situation in which we test 0xffffffff is
|
less than ideal. Caveat user. */
|
less than ideal. Caveat user. */
|
if (mode_sz == 0)
|
if (mode_sz == 0)
|
mode_sz = BIGGEST_ALIGNMENT / BITS_PER_UNIT;
|
mode_sz = BIGGEST_ALIGNMENT / BITS_PER_UNIT;
|
|
|
/* If the expression contains a constant term,
|
/* If the expression contains a constant term,
|
see if it remains valid when max possible offset is added. */
|
see if it remains valid when max possible offset is added. */
|
|
|
if ((ycode == PLUS) && (y2 = find_constant_term_loc (&y1)))
|
if ((ycode == PLUS) && (y2 = find_constant_term_loc (&y1)))
|
{
|
{
|
int good;
|
int good;
|
|
|
y1 = *y2;
|
y1 = *y2;
|
*y2 = plus_constant (*y2, mode_sz - 1);
|
*y2 = plus_constant (*y2, mode_sz - 1);
|
/* Use QImode because an odd displacement may be automatically invalid
|
/* Use QImode because an odd displacement may be automatically invalid
|
for any wider mode. But it should be valid for a single byte. */
|
for any wider mode. But it should be valid for a single byte. */
|
good = (*addressp) (QImode, y);
|
good = (*addressp) (QImode, y);
|
|
|
/* In any case, restore old contents of memory. */
|
/* In any case, restore old contents of memory. */
|
*y2 = y1;
|
*y2 = y1;
|
return good;
|
return good;
|
}
|
}
|
|
|
if (GET_RTX_CLASS (ycode) == RTX_AUTOINC)
|
if (GET_RTX_CLASS (ycode) == RTX_AUTOINC)
|
return 0;
|
return 0;
|
|
|
/* The offset added here is chosen as the maximum offset that
|
/* The offset added here is chosen as the maximum offset that
|
any instruction could need to add when operating on something
|
any instruction could need to add when operating on something
|
of the specified mode. We assume that if Y and Y+c are
|
of the specified mode. We assume that if Y and Y+c are
|
valid addresses then so is Y+d for all 0<d<c. adjust_address will
|
valid addresses then so is Y+d for all 0<d<c. adjust_address will
|
go inside a LO_SUM here, so we do so as well. */
|
go inside a LO_SUM here, so we do so as well. */
|
if (GET_CODE (y) == LO_SUM
|
if (GET_CODE (y) == LO_SUM
|
&& mode != BLKmode
|
&& mode != BLKmode
|
&& mode_sz <= GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT)
|
&& mode_sz <= GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT)
|
z = gen_rtx_LO_SUM (GET_MODE (y), XEXP (y, 0),
|
z = gen_rtx_LO_SUM (GET_MODE (y), XEXP (y, 0),
|
plus_constant (XEXP (y, 1), mode_sz - 1));
|
plus_constant (XEXP (y, 1), mode_sz - 1));
|
else
|
else
|
z = plus_constant (y, mode_sz - 1);
|
z = plus_constant (y, mode_sz - 1);
|
|
|
/* Use QImode because an odd displacement may be automatically invalid
|
/* Use QImode because an odd displacement may be automatically invalid
|
for any wider mode. But it should be valid for a single byte. */
|
for any wider mode. But it should be valid for a single byte. */
|
return (*addressp) (QImode, z);
|
return (*addressp) (QImode, z);
|
}
|
}
|
|
|
/* Return 1 if ADDR is an address-expression whose effect depends
|
/* Return 1 if ADDR is an address-expression whose effect depends
|
on the mode of the memory reference it is used in.
|
on the mode of the memory reference it is used in.
|
|
|
Autoincrement addressing is a typical example of mode-dependence
|
Autoincrement addressing is a typical example of mode-dependence
|
because the amount of the increment depends on the mode. */
|
because the amount of the increment depends on the mode. */
|
|
|
int
|
int
|
mode_dependent_address_p (rtx addr ATTRIBUTE_UNUSED /* Maybe used in GO_IF_MODE_DEPENDENT_ADDRESS. */)
|
mode_dependent_address_p (rtx addr ATTRIBUTE_UNUSED /* Maybe used in GO_IF_MODE_DEPENDENT_ADDRESS. */)
|
{
|
{
|
GO_IF_MODE_DEPENDENT_ADDRESS (addr, win);
|
GO_IF_MODE_DEPENDENT_ADDRESS (addr, win);
|
return 0;
|
return 0;
|
/* Label `win' might (not) be used via GO_IF_MODE_DEPENDENT_ADDRESS. */
|
/* Label `win' might (not) be used via GO_IF_MODE_DEPENDENT_ADDRESS. */
|
win: ATTRIBUTE_UNUSED_LABEL
|
win: ATTRIBUTE_UNUSED_LABEL
|
return 1;
|
return 1;
|
}
|
}
|
|
|
/* Like extract_insn, but save insn extracted and don't extract again, when
|
/* Like extract_insn, but save insn extracted and don't extract again, when
|
called again for the same insn expecting that recog_data still contain the
|
called again for the same insn expecting that recog_data still contain the
|
valid information. This is used primary by gen_attr infrastructure that
|
valid information. This is used primary by gen_attr infrastructure that
|
often does extract insn again and again. */
|
often does extract insn again and again. */
|
void
|
void
|
extract_insn_cached (rtx insn)
|
extract_insn_cached (rtx insn)
|
{
|
{
|
if (recog_data.insn == insn && INSN_CODE (insn) >= 0)
|
if (recog_data.insn == insn && INSN_CODE (insn) >= 0)
|
return;
|
return;
|
extract_insn (insn);
|
extract_insn (insn);
|
recog_data.insn = insn;
|
recog_data.insn = insn;
|
}
|
}
|
|
|
/* Do cached extract_insn, constrain_operands and complain about failures.
|
/* Do cached extract_insn, constrain_operands and complain about failures.
|
Used by insn_attrtab. */
|
Used by insn_attrtab. */
|
void
|
void
|
extract_constrain_insn_cached (rtx insn)
|
extract_constrain_insn_cached (rtx insn)
|
{
|
{
|
extract_insn_cached (insn);
|
extract_insn_cached (insn);
|
if (which_alternative == -1
|
if (which_alternative == -1
|
&& !constrain_operands (reload_completed))
|
&& !constrain_operands (reload_completed))
|
fatal_insn_not_found (insn);
|
fatal_insn_not_found (insn);
|
}
|
}
|
|
|
/* Do cached constrain_operands and complain about failures. */
|
/* Do cached constrain_operands and complain about failures. */
|
int
|
int
|
constrain_operands_cached (int strict)
|
constrain_operands_cached (int strict)
|
{
|
{
|
if (which_alternative == -1)
|
if (which_alternative == -1)
|
return constrain_operands (strict);
|
return constrain_operands (strict);
|
else
|
else
|
return 1;
|
return 1;
|
}
|
}
|
|
|
/* Analyze INSN and fill in recog_data. */
|
/* Analyze INSN and fill in recog_data. */
|
|
|
void
|
void
|
extract_insn (rtx insn)
|
extract_insn (rtx insn)
|
{
|
{
|
int i;
|
int i;
|
int icode;
|
int icode;
|
int noperands;
|
int noperands;
|
rtx body = PATTERN (insn);
|
rtx body = PATTERN (insn);
|
|
|
recog_data.insn = NULL;
|
recog_data.insn = NULL;
|
recog_data.n_operands = 0;
|
recog_data.n_operands = 0;
|
recog_data.n_alternatives = 0;
|
recog_data.n_alternatives = 0;
|
recog_data.n_dups = 0;
|
recog_data.n_dups = 0;
|
which_alternative = -1;
|
which_alternative = -1;
|
|
|
switch (GET_CODE (body))
|
switch (GET_CODE (body))
|
{
|
{
|
case USE:
|
case USE:
|
case CLOBBER:
|
case CLOBBER:
|
case ASM_INPUT:
|
case ASM_INPUT:
|
case ADDR_VEC:
|
case ADDR_VEC:
|
case ADDR_DIFF_VEC:
|
case ADDR_DIFF_VEC:
|
return;
|
return;
|
|
|
case SET:
|
case SET:
|
if (GET_CODE (SET_SRC (body)) == ASM_OPERANDS)
|
if (GET_CODE (SET_SRC (body)) == ASM_OPERANDS)
|
goto asm_insn;
|
goto asm_insn;
|
else
|
else
|
goto normal_insn;
|
goto normal_insn;
|
case PARALLEL:
|
case PARALLEL:
|
if ((GET_CODE (XVECEXP (body, 0, 0)) == SET
|
if ((GET_CODE (XVECEXP (body, 0, 0)) == SET
|
&& GET_CODE (SET_SRC (XVECEXP (body, 0, 0))) == ASM_OPERANDS)
|
&& GET_CODE (SET_SRC (XVECEXP (body, 0, 0))) == ASM_OPERANDS)
|
|| GET_CODE (XVECEXP (body, 0, 0)) == ASM_OPERANDS)
|
|| GET_CODE (XVECEXP (body, 0, 0)) == ASM_OPERANDS)
|
goto asm_insn;
|
goto asm_insn;
|
else
|
else
|
goto normal_insn;
|
goto normal_insn;
|
case ASM_OPERANDS:
|
case ASM_OPERANDS:
|
asm_insn:
|
asm_insn:
|
recog_data.n_operands = noperands = asm_noperands (body);
|
recog_data.n_operands = noperands = asm_noperands (body);
|
if (noperands >= 0)
|
if (noperands >= 0)
|
{
|
{
|
/* This insn is an `asm' with operands. */
|
/* This insn is an `asm' with operands. */
|
|
|
/* expand_asm_operands makes sure there aren't too many operands. */
|
/* expand_asm_operands makes sure there aren't too many operands. */
|
gcc_assert (noperands <= MAX_RECOG_OPERANDS);
|
gcc_assert (noperands <= MAX_RECOG_OPERANDS);
|
|
|
/* Now get the operand values and constraints out of the insn. */
|
/* Now get the operand values and constraints out of the insn. */
|
decode_asm_operands (body, recog_data.operand,
|
decode_asm_operands (body, recog_data.operand,
|
recog_data.operand_loc,
|
recog_data.operand_loc,
|
recog_data.constraints,
|
recog_data.constraints,
|
recog_data.operand_mode);
|
recog_data.operand_mode);
|
if (noperands > 0)
|
if (noperands > 0)
|
{
|
{
|
const char *p = recog_data.constraints[0];
|
const char *p = recog_data.constraints[0];
|
recog_data.n_alternatives = 1;
|
recog_data.n_alternatives = 1;
|
while (*p)
|
while (*p)
|
recog_data.n_alternatives += (*p++ == ',');
|
recog_data.n_alternatives += (*p++ == ',');
|
}
|
}
|
break;
|
break;
|
}
|
}
|
fatal_insn_not_found (insn);
|
fatal_insn_not_found (insn);
|
|
|
default:
|
default:
|
normal_insn:
|
normal_insn:
|
/* Ordinary insn: recognize it, get the operands via insn_extract
|
/* Ordinary insn: recognize it, get the operands via insn_extract
|
and get the constraints. */
|
and get the constraints. */
|
|
|
icode = recog_memoized (insn);
|
icode = recog_memoized (insn);
|
if (icode < 0)
|
if (icode < 0)
|
fatal_insn_not_found (insn);
|
fatal_insn_not_found (insn);
|
|
|
recog_data.n_operands = noperands = insn_data[icode].n_operands;
|
recog_data.n_operands = noperands = insn_data[icode].n_operands;
|
recog_data.n_alternatives = insn_data[icode].n_alternatives;
|
recog_data.n_alternatives = insn_data[icode].n_alternatives;
|
recog_data.n_dups = insn_data[icode].n_dups;
|
recog_data.n_dups = insn_data[icode].n_dups;
|
|
|
insn_extract (insn);
|
insn_extract (insn);
|
|
|
for (i = 0; i < noperands; i++)
|
for (i = 0; i < noperands; i++)
|
{
|
{
|
recog_data.constraints[i] = insn_data[icode].operand[i].constraint;
|
recog_data.constraints[i] = insn_data[icode].operand[i].constraint;
|
recog_data.operand_mode[i] = insn_data[icode].operand[i].mode;
|
recog_data.operand_mode[i] = insn_data[icode].operand[i].mode;
|
/* VOIDmode match_operands gets mode from their real operand. */
|
/* VOIDmode match_operands gets mode from their real operand. */
|
if (recog_data.operand_mode[i] == VOIDmode)
|
if (recog_data.operand_mode[i] == VOIDmode)
|
recog_data.operand_mode[i] = GET_MODE (recog_data.operand[i]);
|
recog_data.operand_mode[i] = GET_MODE (recog_data.operand[i]);
|
}
|
}
|
}
|
}
|
for (i = 0; i < noperands; i++)
|
for (i = 0; i < noperands; i++)
|
recog_data.operand_type[i]
|
recog_data.operand_type[i]
|
= (recog_data.constraints[i][0] == '=' ? OP_OUT
|
= (recog_data.constraints[i][0] == '=' ? OP_OUT
|
: recog_data.constraints[i][0] == '+' ? OP_INOUT
|
: recog_data.constraints[i][0] == '+' ? OP_INOUT
|
: OP_IN);
|
: OP_IN);
|
|
|
gcc_assert (recog_data.n_alternatives <= MAX_RECOG_ALTERNATIVES);
|
gcc_assert (recog_data.n_alternatives <= MAX_RECOG_ALTERNATIVES);
|
}
|
}
|
|
|
/* After calling extract_insn, you can use this function to extract some
|
/* After calling extract_insn, you can use this function to extract some
|
information from the constraint strings into a more usable form.
|
information from the constraint strings into a more usable form.
|
The collected data is stored in recog_op_alt. */
|
The collected data is stored in recog_op_alt. */
|
void
|
void
|
preprocess_constraints (void)
|
preprocess_constraints (void)
|
{
|
{
|
int i;
|
int i;
|
|
|
for (i = 0; i < recog_data.n_operands; i++)
|
for (i = 0; i < recog_data.n_operands; i++)
|
memset (recog_op_alt[i], 0, (recog_data.n_alternatives
|
memset (recog_op_alt[i], 0, (recog_data.n_alternatives
|
* sizeof (struct operand_alternative)));
|
* sizeof (struct operand_alternative)));
|
|
|
for (i = 0; i < recog_data.n_operands; i++)
|
for (i = 0; i < recog_data.n_operands; i++)
|
{
|
{
|
int j;
|
int j;
|
struct operand_alternative *op_alt;
|
struct operand_alternative *op_alt;
|
const char *p = recog_data.constraints[i];
|
const char *p = recog_data.constraints[i];
|
|
|
op_alt = recog_op_alt[i];
|
op_alt = recog_op_alt[i];
|
|
|
for (j = 0; j < recog_data.n_alternatives; j++)
|
for (j = 0; j < recog_data.n_alternatives; j++)
|
{
|
{
|
op_alt[j].cl = NO_REGS;
|
op_alt[j].cl = NO_REGS;
|
op_alt[j].constraint = p;
|
op_alt[j].constraint = p;
|
op_alt[j].matches = -1;
|
op_alt[j].matches = -1;
|
op_alt[j].matched = -1;
|
op_alt[j].matched = -1;
|
|
|
if (*p == '\0' || *p == ',')
|
if (*p == '\0' || *p == ',')
|
{
|
{
|
op_alt[j].anything_ok = 1;
|
op_alt[j].anything_ok = 1;
|
continue;
|
continue;
|
}
|
}
|
|
|
for (;;)
|
for (;;)
|
{
|
{
|
char c = *p;
|
char c = *p;
|
if (c == '#')
|
if (c == '#')
|
do
|
do
|
c = *++p;
|
c = *++p;
|
while (c != ',' && c != '\0');
|
while (c != ',' && c != '\0');
|
if (c == ',' || c == '\0')
|
if (c == ',' || c == '\0')
|
{
|
{
|
p++;
|
p++;
|
break;
|
break;
|
}
|
}
|
|
|
switch (c)
|
switch (c)
|
{
|
{
|
case '=': case '+': case '*': case '%':
|
case '=': case '+': case '*': case '%':
|
case 'E': case 'F': case 'G': case 'H':
|
case 'E': case 'F': case 'G': case 'H':
|
case 's': case 'i': case 'n':
|
case 's': case 'i': case 'n':
|
case 'I': case 'J': case 'K': case 'L':
|
case 'I': case 'J': case 'K': case 'L':
|
case 'M': case 'N': case 'O': case 'P':
|
case 'M': case 'N': case 'O': case 'P':
|
/* These don't say anything we care about. */
|
/* These don't say anything we care about. */
|
break;
|
break;
|
|
|
case '?':
|
case '?':
|
op_alt[j].reject += 6;
|
op_alt[j].reject += 6;
|
break;
|
break;
|
case '!':
|
case '!':
|
op_alt[j].reject += 600;
|
op_alt[j].reject += 600;
|
break;
|
break;
|
case '&':
|
case '&':
|
op_alt[j].earlyclobber = 1;
|
op_alt[j].earlyclobber = 1;
|
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':
|
{
|
{
|
char *end;
|
char *end;
|
op_alt[j].matches = strtoul (p, &end, 10);
|
op_alt[j].matches = strtoul (p, &end, 10);
|
recog_op_alt[op_alt[j].matches][j].matched = i;
|
recog_op_alt[op_alt[j].matches][j].matched = i;
|
p = end;
|
p = end;
|
}
|
}
|
continue;
|
continue;
|
|
|
case 'm':
|
case 'm':
|
op_alt[j].memory_ok = 1;
|
op_alt[j].memory_ok = 1;
|
break;
|
break;
|
case '<':
|
case '<':
|
op_alt[j].decmem_ok = 1;
|
op_alt[j].decmem_ok = 1;
|
break;
|
break;
|
case '>':
|
case '>':
|
op_alt[j].incmem_ok = 1;
|
op_alt[j].incmem_ok = 1;
|
break;
|
break;
|
case 'V':
|
case 'V':
|
op_alt[j].nonoffmem_ok = 1;
|
op_alt[j].nonoffmem_ok = 1;
|
break;
|
break;
|
case 'o':
|
case 'o':
|
op_alt[j].offmem_ok = 1;
|
op_alt[j].offmem_ok = 1;
|
break;
|
break;
|
case 'X':
|
case 'X':
|
op_alt[j].anything_ok = 1;
|
op_alt[j].anything_ok = 1;
|
break;
|
break;
|
|
|
case 'p':
|
case 'p':
|
op_alt[j].is_address = 1;
|
op_alt[j].is_address = 1;
|
op_alt[j].cl = reg_class_subunion[(int) op_alt[j].cl]
|
op_alt[j].cl = reg_class_subunion[(int) op_alt[j].cl]
|
[(int) base_reg_class (VOIDmode, ADDRESS, SCRATCH)];
|
[(int) base_reg_class (VOIDmode, ADDRESS, SCRATCH)];
|
break;
|
break;
|
|
|
case 'g':
|
case 'g':
|
case 'r':
|
case 'r':
|
op_alt[j].cl =
|
op_alt[j].cl =
|
reg_class_subunion[(int) op_alt[j].cl][(int) GENERAL_REGS];
|
reg_class_subunion[(int) op_alt[j].cl][(int) GENERAL_REGS];
|
break;
|
break;
|
|
|
default:
|
default:
|
if (EXTRA_MEMORY_CONSTRAINT (c, p))
|
if (EXTRA_MEMORY_CONSTRAINT (c, p))
|
{
|
{
|
op_alt[j].memory_ok = 1;
|
op_alt[j].memory_ok = 1;
|
break;
|
break;
|
}
|
}
|
if (EXTRA_ADDRESS_CONSTRAINT (c, p))
|
if (EXTRA_ADDRESS_CONSTRAINT (c, p))
|
{
|
{
|
op_alt[j].is_address = 1;
|
op_alt[j].is_address = 1;
|
op_alt[j].cl
|
op_alt[j].cl
|
= (reg_class_subunion
|
= (reg_class_subunion
|
[(int) op_alt[j].cl]
|
[(int) op_alt[j].cl]
|
[(int) base_reg_class (VOIDmode, ADDRESS,
|
[(int) base_reg_class (VOIDmode, ADDRESS,
|
SCRATCH)]);
|
SCRATCH)]);
|
break;
|
break;
|
}
|
}
|
|
|
op_alt[j].cl
|
op_alt[j].cl
|
= (reg_class_subunion
|
= (reg_class_subunion
|
[(int) op_alt[j].cl]
|
[(int) op_alt[j].cl]
|
[(int) REG_CLASS_FROM_CONSTRAINT ((unsigned char) c, p)]);
|
[(int) REG_CLASS_FROM_CONSTRAINT ((unsigned char) c, p)]);
|
break;
|
break;
|
}
|
}
|
p += CONSTRAINT_LEN (c, p);
|
p += CONSTRAINT_LEN (c, p);
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Check the operands of an insn against the insn's operand constraints
|
/* Check the operands of an insn against the insn's operand constraints
|
and return 1 if they are valid.
|
and return 1 if they are valid.
|
The information about the insn's operands, constraints, operand modes
|
The information about the insn's operands, constraints, operand modes
|
etc. is obtained from the global variables set up by extract_insn.
|
etc. is obtained from the global variables set up by extract_insn.
|
|
|
WHICH_ALTERNATIVE is set to a number which indicates which
|
WHICH_ALTERNATIVE is set to a number which indicates which
|
alternative of constraints was matched: 0 for the first alternative,
|
alternative of constraints was matched: 0 for the first alternative,
|
1 for the next, etc.
|
1 for the next, etc.
|
|
|
In addition, when two operands are required to match
|
In addition, when two operands are required to match
|
and it happens that the output operand is (reg) while the
|
and it happens that the output operand is (reg) while the
|
input operand is --(reg) or ++(reg) (a pre-inc or pre-dec),
|
input operand is --(reg) or ++(reg) (a pre-inc or pre-dec),
|
make the output operand look like the input.
|
make the output operand look like the input.
|
This is because the output operand is the one the template will print.
|
This is because the output operand is the one the template will print.
|
|
|
This is used in final, just before printing the assembler code and by
|
This is used in final, just before printing the assembler code and by
|
the routines that determine an insn's attribute.
|
the routines that determine an insn's attribute.
|
|
|
If STRICT is a positive nonzero value, it means that we have been
|
If STRICT is a positive nonzero value, it means that we have been
|
called after reload has been completed. In that case, we must
|
called after reload has been completed. In that case, we must
|
do all checks strictly. If it is zero, it means that we have been called
|
do all checks strictly. If it is zero, it means that we have been called
|
before reload has completed. In that case, we first try to see if we can
|
before reload has completed. In that case, we first try to see if we can
|
find an alternative that matches strictly. If not, we try again, this
|
find an alternative that matches strictly. If not, we try again, this
|
time assuming that reload will fix up the insn. This provides a "best
|
time assuming that reload will fix up the insn. This provides a "best
|
guess" for the alternative and is used to compute attributes of insns prior
|
guess" for the alternative and is used to compute attributes of insns prior
|
to reload. A negative value of STRICT is used for this internal call. */
|
to reload. A negative value of STRICT is used for this internal call. */
|
|
|
struct funny_match
|
struct funny_match
|
{
|
{
|
int this, other;
|
int this, other;
|
};
|
};
|
|
|
int
|
int
|
constrain_operands (int strict)
|
constrain_operands (int strict)
|
{
|
{
|
const char *constraints[MAX_RECOG_OPERANDS];
|
const char *constraints[MAX_RECOG_OPERANDS];
|
int matching_operands[MAX_RECOG_OPERANDS];
|
int matching_operands[MAX_RECOG_OPERANDS];
|
int earlyclobber[MAX_RECOG_OPERANDS];
|
int earlyclobber[MAX_RECOG_OPERANDS];
|
int c;
|
int c;
|
|
|
struct funny_match funny_match[MAX_RECOG_OPERANDS];
|
struct funny_match funny_match[MAX_RECOG_OPERANDS];
|
int funny_match_index;
|
int funny_match_index;
|
|
|
which_alternative = 0;
|
which_alternative = 0;
|
if (recog_data.n_operands == 0 || recog_data.n_alternatives == 0)
|
if (recog_data.n_operands == 0 || recog_data.n_alternatives == 0)
|
return 1;
|
return 1;
|
|
|
for (c = 0; c < recog_data.n_operands; c++)
|
for (c = 0; c < recog_data.n_operands; c++)
|
{
|
{
|
constraints[c] = recog_data.constraints[c];
|
constraints[c] = recog_data.constraints[c];
|
matching_operands[c] = -1;
|
matching_operands[c] = -1;
|
}
|
}
|
|
|
do
|
do
|
{
|
{
|
int seen_earlyclobber_at = -1;
|
int seen_earlyclobber_at = -1;
|
int opno;
|
int opno;
|
int lose = 0;
|
int lose = 0;
|
funny_match_index = 0;
|
funny_match_index = 0;
|
|
|
for (opno = 0; opno < recog_data.n_operands; opno++)
|
for (opno = 0; opno < recog_data.n_operands; opno++)
|
{
|
{
|
rtx op = recog_data.operand[opno];
|
rtx op = recog_data.operand[opno];
|
enum machine_mode mode = GET_MODE (op);
|
enum machine_mode mode = GET_MODE (op);
|
const char *p = constraints[opno];
|
const char *p = constraints[opno];
|
int offset = 0;
|
int offset = 0;
|
int win = 0;
|
int win = 0;
|
int val;
|
int val;
|
int len;
|
int len;
|
|
|
earlyclobber[opno] = 0;
|
earlyclobber[opno] = 0;
|
|
|
/* A unary operator may be accepted by the predicate, but it
|
/* A unary operator may be accepted by the predicate, but it
|
is irrelevant for matching constraints. */
|
is irrelevant for matching constraints. */
|
if (UNARY_P (op))
|
if (UNARY_P (op))
|
op = XEXP (op, 0);
|
op = XEXP (op, 0);
|
|
|
if (GET_CODE (op) == SUBREG)
|
if (GET_CODE (op) == SUBREG)
|
{
|
{
|
if (REG_P (SUBREG_REG (op))
|
if (REG_P (SUBREG_REG (op))
|
&& REGNO (SUBREG_REG (op)) < FIRST_PSEUDO_REGISTER)
|
&& REGNO (SUBREG_REG (op)) < FIRST_PSEUDO_REGISTER)
|
offset = subreg_regno_offset (REGNO (SUBREG_REG (op)),
|
offset = subreg_regno_offset (REGNO (SUBREG_REG (op)),
|
GET_MODE (SUBREG_REG (op)),
|
GET_MODE (SUBREG_REG (op)),
|
SUBREG_BYTE (op),
|
SUBREG_BYTE (op),
|
GET_MODE (op));
|
GET_MODE (op));
|
op = SUBREG_REG (op);
|
op = SUBREG_REG (op);
|
}
|
}
|
|
|
/* 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;
|
win = 1;
|
|
|
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 '!': case '*': case '%':
|
case '=': case '+':
|
case '=': case '+':
|
break;
|
break;
|
|
|
case '#':
|
case '#':
|
/* Ignore rest of this alternative as far as
|
/* Ignore rest of this alternative as far as
|
constraint checking is concerned. */
|
constraint checking is concerned. */
|
do
|
do
|
p++;
|
p++;
|
while (*p && *p != ',');
|
while (*p && *p != ',');
|
len = 0;
|
len = 0;
|
break;
|
break;
|
|
|
case '&':
|
case '&':
|
earlyclobber[opno] = 1;
|
earlyclobber[opno] = 1;
|
if (seen_earlyclobber_at < 0)
|
if (seen_earlyclobber_at < 0)
|
seen_earlyclobber_at = opno;
|
seen_earlyclobber_at = opno;
|
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':
|
{
|
{
|
/* This operand must be the same as a previous one.
|
/* This operand must be the same as a previous one.
|
This kind of constraint is used for instructions such
|
This kind of constraint is used for instructions such
|
as add when they take only two operands.
|
as add when they take only two operands.
|
|
|
Note that the lower-numbered operand is passed first.
|
Note that the lower-numbered operand is passed first.
|
|
|
If we are not testing strictly, assume that this
|
If we are not testing strictly, assume that this
|
constraint will be satisfied. */
|
constraint will be satisfied. */
|
|
|
char *end;
|
char *end;
|
int match;
|
int match;
|
|
|
match = strtoul (p, &end, 10);
|
match = strtoul (p, &end, 10);
|
p = end;
|
p = end;
|
|
|
if (strict < 0)
|
if (strict < 0)
|
val = 1;
|
val = 1;
|
else
|
else
|
{
|
{
|
rtx op1 = recog_data.operand[match];
|
rtx op1 = recog_data.operand[match];
|
rtx op2 = recog_data.operand[opno];
|
rtx op2 = recog_data.operand[opno];
|
|
|
/* A unary operator may be accepted by the predicate,
|
/* A unary operator may be accepted by the predicate,
|
but it is irrelevant for matching constraints. */
|
but it is irrelevant for matching constraints. */
|
if (UNARY_P (op1))
|
if (UNARY_P (op1))
|
op1 = XEXP (op1, 0);
|
op1 = XEXP (op1, 0);
|
if (UNARY_P (op2))
|
if (UNARY_P (op2))
|
op2 = XEXP (op2, 0);
|
op2 = XEXP (op2, 0);
|
|
|
val = operands_match_p (op1, op2);
|
val = operands_match_p (op1, op2);
|
}
|
}
|
|
|
matching_operands[opno] = match;
|
matching_operands[opno] = match;
|
matching_operands[match] = opno;
|
matching_operands[match] = opno;
|
|
|
if (val != 0)
|
if (val != 0)
|
win = 1;
|
win = 1;
|
|
|
/* If output is *x and input is *--x, arrange later
|
/* If output is *x and input is *--x, arrange later
|
to change the output to *--x as well, since the
|
to change the output to *--x as well, since the
|
output op is the one that will be printed. */
|
output op is the one that will be printed. */
|
if (val == 2 && strict > 0)
|
if (val == 2 && strict > 0)
|
{
|
{
|
funny_match[funny_match_index].this = opno;
|
funny_match[funny_match_index].this = opno;
|
funny_match[funny_match_index++].other = match;
|
funny_match[funny_match_index++].other = match;
|
}
|
}
|
}
|
}
|
len = 0;
|
len = 0;
|
break;
|
break;
|
|
|
case 'p':
|
case 'p':
|
/* p is used for address_operands. When we are called by
|
/* p is used for address_operands. When we are called by
|
gen_reload, no one will have checked that the address is
|
gen_reload, no one will have checked that the address is
|
strictly valid, i.e., that all pseudos requiring hard regs
|
strictly valid, i.e., that all pseudos requiring hard regs
|
have gotten them. */
|
have gotten them. */
|
if (strict <= 0
|
if (strict <= 0
|
|| (strict_memory_address_p (recog_data.operand_mode[opno],
|
|| (strict_memory_address_p (recog_data.operand_mode[opno],
|
op)))
|
op)))
|
win = 1;
|
win = 1;
|
break;
|
break;
|
|
|
/* No need to check general_operand again;
|
/* No need to check general_operand again;
|
it was done in insn-recog.c. Well, except that reload
|
it was done in insn-recog.c. Well, except that reload
|
doesn't check the validity of its replacements, but
|
doesn't check the validity of its replacements, but
|
that should only matter when there's a bug. */
|
that should only matter when there's a bug. */
|
case 'g':
|
case 'g':
|
/* Anything goes unless it is a REG and really has a hard reg
|
/* Anything goes unless it is a REG and really has a hard reg
|
but the hard reg is not in the class GENERAL_REGS. */
|
but the hard reg is not in the class GENERAL_REGS. */
|
if (REG_P (op))
|
if (REG_P (op))
|
{
|
{
|
if (strict < 0
|
if (strict < 0
|
|| GENERAL_REGS == ALL_REGS
|
|| GENERAL_REGS == ALL_REGS
|
|| (reload_in_progress
|
|| (reload_in_progress
|
&& REGNO (op) >= FIRST_PSEUDO_REGISTER)
|
&& REGNO (op) >= FIRST_PSEUDO_REGISTER)
|
|| reg_fits_class_p (op, GENERAL_REGS, offset, mode))
|
|| reg_fits_class_p (op, GENERAL_REGS, offset, mode))
|
win = 1;
|
win = 1;
|
}
|
}
|
else if (strict < 0 || general_operand (op, mode))
|
else if (strict < 0 || general_operand (op, mode))
|
win = 1;
|
win = 1;
|
break;
|
break;
|
|
|
case 'X':
|
case 'X':
|
/* This is used for a MATCH_SCRATCH in the cases when
|
/* This is used for a MATCH_SCRATCH in the cases when
|
we don't actually need anything. So anything goes
|
we don't actually need anything. So anything goes
|
any time. */
|
any time. */
|
win = 1;
|
win = 1;
|
break;
|
break;
|
|
|
case 'm':
|
case 'm':
|
/* Memory operands must be valid, to the extent
|
/* Memory operands must be valid, to the extent
|
required by STRICT. */
|
required by STRICT. */
|
if (MEM_P (op))
|
if (MEM_P (op))
|
{
|
{
|
if (strict > 0
|
if (strict > 0
|
&& !strict_memory_address_p (GET_MODE (op),
|
&& !strict_memory_address_p (GET_MODE (op),
|
XEXP (op, 0)))
|
XEXP (op, 0)))
|
break;
|
break;
|
if (strict == 0
|
if (strict == 0
|
&& !memory_address_p (GET_MODE (op), XEXP (op, 0)))
|
&& !memory_address_p (GET_MODE (op), XEXP (op, 0)))
|
break;
|
break;
|
win = 1;
|
win = 1;
|
}
|
}
|
/* Before reload, accept what reload can turn into mem. */
|
/* Before reload, accept what reload can turn into mem. */
|
else if (strict < 0 && CONSTANT_P (op))
|
else if (strict < 0 && CONSTANT_P (op))
|
win = 1;
|
win = 1;
|
/* During reload, accept a pseudo */
|
/* During reload, accept a pseudo */
|
else if (reload_in_progress && REG_P (op)
|
else if (reload_in_progress && REG_P (op)
|
&& REGNO (op) >= FIRST_PSEUDO_REGISTER)
|
&& REGNO (op) >= FIRST_PSEUDO_REGISTER)
|
win = 1;
|
win = 1;
|
break;
|
break;
|
|
|
case '<':
|
case '<':
|
if (MEM_P (op)
|
if (MEM_P (op)
|
&& (GET_CODE (XEXP (op, 0)) == PRE_DEC
|
&& (GET_CODE (XEXP (op, 0)) == PRE_DEC
|
|| GET_CODE (XEXP (op, 0)) == POST_DEC))
|
|| GET_CODE (XEXP (op, 0)) == POST_DEC))
|
win = 1;
|
win = 1;
|
break;
|
break;
|
|
|
case '>':
|
case '>':
|
if (MEM_P (op)
|
if (MEM_P (op)
|
&& (GET_CODE (XEXP (op, 0)) == PRE_INC
|
&& (GET_CODE (XEXP (op, 0)) == PRE_INC
|
|| GET_CODE (XEXP (op, 0)) == POST_INC))
|
|| GET_CODE (XEXP (op, 0)) == POST_INC))
|
win = 1;
|
win = 1;
|
break;
|
break;
|
|
|
case 'E':
|
case 'E':
|
case 'F':
|
case 'F':
|
if (GET_CODE (op) == CONST_DOUBLE
|
if (GET_CODE (op) == CONST_DOUBLE
|
|| (GET_CODE (op) == CONST_VECTOR
|
|| (GET_CODE (op) == CONST_VECTOR
|
&& GET_MODE_CLASS (GET_MODE (op)) == MODE_VECTOR_FLOAT))
|
&& GET_MODE_CLASS (GET_MODE (op)) == MODE_VECTOR_FLOAT))
|
win = 1;
|
win = 1;
|
break;
|
break;
|
|
|
case 'G':
|
case 'G':
|
case 'H':
|
case 'H':
|
if (GET_CODE (op) == CONST_DOUBLE
|
if (GET_CODE (op) == CONST_DOUBLE
|
&& CONST_DOUBLE_OK_FOR_CONSTRAINT_P (op, c, p))
|
&& CONST_DOUBLE_OK_FOR_CONSTRAINT_P (op, c, p))
|
win = 1;
|
win = 1;
|
break;
|
break;
|
|
|
case 's':
|
case 's':
|
if (GET_CODE (op) == CONST_INT
|
if (GET_CODE (op) == CONST_INT
|
|| (GET_CODE (op) == CONST_DOUBLE
|
|| (GET_CODE (op) == CONST_DOUBLE
|
&& GET_MODE (op) == VOIDmode))
|
&& GET_MODE (op) == VOIDmode))
|
break;
|
break;
|
case 'i':
|
case 'i':
|
if (CONSTANT_P (op))
|
if (CONSTANT_P (op))
|
win = 1;
|
win = 1;
|
break;
|
break;
|
|
|
case 'n':
|
case 'n':
|
if (GET_CODE (op) == CONST_INT
|
if (GET_CODE (op) == CONST_INT
|
|| (GET_CODE (op) == CONST_DOUBLE
|
|| (GET_CODE (op) == CONST_DOUBLE
|
&& GET_MODE (op) == VOIDmode))
|
&& GET_MODE (op) == 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 (op) == CONST_INT
|
if (GET_CODE (op) == CONST_INT
|
&& CONST_OK_FOR_CONSTRAINT_P (INTVAL (op), c, p))
|
&& CONST_OK_FOR_CONSTRAINT_P (INTVAL (op), c, p))
|
win = 1;
|
win = 1;
|
break;
|
break;
|
|
|
case 'V':
|
case 'V':
|
if (MEM_P (op)
|
if (MEM_P (op)
|
&& ((strict > 0 && ! offsettable_memref_p (op))
|
&& ((strict > 0 && ! offsettable_memref_p (op))
|
|| (strict < 0
|
|| (strict < 0
|
&& !(CONSTANT_P (op) || MEM_P (op)))
|
&& !(CONSTANT_P (op) || MEM_P (op)))
|
|| (reload_in_progress
|
|| (reload_in_progress
|
&& !(REG_P (op)
|
&& !(REG_P (op)
|
&& REGNO (op) >= FIRST_PSEUDO_REGISTER))))
|
&& REGNO (op) >= FIRST_PSEUDO_REGISTER))))
|
win = 1;
|
win = 1;
|
break;
|
break;
|
|
|
case 'o':
|
case 'o':
|
if ((strict > 0 && offsettable_memref_p (op))
|
if ((strict > 0 && offsettable_memref_p (op))
|
|| (strict == 0 && offsettable_nonstrict_memref_p (op))
|
|| (strict == 0 && offsettable_nonstrict_memref_p (op))
|
/* Before reload, accept what reload can handle. */
|
/* Before reload, accept what reload can handle. */
|
|| (strict < 0
|
|| (strict < 0
|
&& (CONSTANT_P (op) || MEM_P (op)))
|
&& (CONSTANT_P (op) || MEM_P (op)))
|
/* During reload, accept a pseudo */
|
/* During reload, accept a pseudo */
|
|| (reload_in_progress && REG_P (op)
|
|| (reload_in_progress && REG_P (op)
|
&& REGNO (op) >= FIRST_PSEUDO_REGISTER))
|
&& REGNO (op) >= FIRST_PSEUDO_REGISTER))
|
win = 1;
|
win = 1;
|
break;
|
break;
|
|
|
default:
|
default:
|
{
|
{
|
enum reg_class cl;
|
enum reg_class cl;
|
|
|
cl = (c == 'r'
|
cl = (c == 'r'
|
? GENERAL_REGS : REG_CLASS_FROM_CONSTRAINT (c, p));
|
? GENERAL_REGS : REG_CLASS_FROM_CONSTRAINT (c, p));
|
if (cl != NO_REGS)
|
if (cl != NO_REGS)
|
{
|
{
|
if (strict < 0
|
if (strict < 0
|
|| (strict == 0
|
|| (strict == 0
|
&& REG_P (op)
|
&& REG_P (op)
|
&& REGNO (op) >= FIRST_PSEUDO_REGISTER)
|
&& REGNO (op) >= FIRST_PSEUDO_REGISTER)
|
|| (strict == 0 && GET_CODE (op) == SCRATCH)
|
|| (strict == 0 && GET_CODE (op) == SCRATCH)
|
|| (REG_P (op)
|
|| (REG_P (op)
|
&& reg_fits_class_p (op, cl, offset, mode)))
|
&& reg_fits_class_p (op, cl, offset, mode)))
|
win = 1;
|
win = 1;
|
}
|
}
|
#ifdef EXTRA_CONSTRAINT_STR
|
#ifdef EXTRA_CONSTRAINT_STR
|
else if (EXTRA_CONSTRAINT_STR (op, c, p))
|
else if (EXTRA_CONSTRAINT_STR (op, c, p))
|
win = 1;
|
win = 1;
|
|
|
else if (EXTRA_MEMORY_CONSTRAINT (c, p)
|
else if (EXTRA_MEMORY_CONSTRAINT (c, p)
|
/* Every memory operand can be reloaded to fit. */
|
/* Every memory operand can be reloaded to fit. */
|
&& ((strict < 0 && MEM_P (op))
|
&& ((strict < 0 && MEM_P (op))
|
/* Before reload, accept what reload can turn
|
/* Before reload, accept what reload can turn
|
into mem. */
|
into mem. */
|
|| (strict < 0 && CONSTANT_P (op))
|
|| (strict < 0 && CONSTANT_P (op))
|
/* During reload, accept a pseudo */
|
/* During reload, accept a pseudo */
|
|| (reload_in_progress && REG_P (op)
|
|| (reload_in_progress && REG_P (op)
|
&& REGNO (op) >= FIRST_PSEUDO_REGISTER)))
|
&& REGNO (op) >= FIRST_PSEUDO_REGISTER)))
|
win = 1;
|
win = 1;
|
else if (EXTRA_ADDRESS_CONSTRAINT (c, p)
|
else if (EXTRA_ADDRESS_CONSTRAINT (c, p)
|
/* Every address operand can be reloaded to fit. */
|
/* Every address operand can be reloaded to fit. */
|
&& strict < 0)
|
&& strict < 0)
|
win = 1;
|
win = 1;
|
#endif
|
#endif
|
break;
|
break;
|
}
|
}
|
}
|
}
|
while (p += len, c);
|
while (p += len, c);
|
|
|
constraints[opno] = p;
|
constraints[opno] = p;
|
/* If this operand did not win somehow,
|
/* If this operand did not win somehow,
|
this alternative loses. */
|
this alternative loses. */
|
if (! win)
|
if (! win)
|
lose = 1;
|
lose = 1;
|
}
|
}
|
/* This alternative won; the operands are ok.
|
/* This alternative won; the operands are ok.
|
Change whichever operands this alternative says to change. */
|
Change whichever operands this alternative says to change. */
|
if (! lose)
|
if (! lose)
|
{
|
{
|
int opno, eopno;
|
int opno, eopno;
|
|
|
/* See if any earlyclobber operand conflicts with some other
|
/* See if any earlyclobber operand conflicts with some other
|
operand. */
|
operand. */
|
|
|
if (strict > 0 && seen_earlyclobber_at >= 0)
|
if (strict > 0 && seen_earlyclobber_at >= 0)
|
for (eopno = seen_earlyclobber_at;
|
for (eopno = seen_earlyclobber_at;
|
eopno < recog_data.n_operands;
|
eopno < recog_data.n_operands;
|
eopno++)
|
eopno++)
|
/* Ignore earlyclobber operands now in memory,
|
/* Ignore earlyclobber operands now in memory,
|
because we would often report failure when we have
|
because we would often report failure when we have
|
two memory operands, one of which was formerly a REG. */
|
two memory operands, one of which was formerly a REG. */
|
if (earlyclobber[eopno]
|
if (earlyclobber[eopno]
|
&& REG_P (recog_data.operand[eopno]))
|
&& REG_P (recog_data.operand[eopno]))
|
for (opno = 0; opno < recog_data.n_operands; opno++)
|
for (opno = 0; opno < recog_data.n_operands; opno++)
|
if ((MEM_P (recog_data.operand[opno])
|
if ((MEM_P (recog_data.operand[opno])
|
|| recog_data.operand_type[opno] != OP_OUT)
|
|| recog_data.operand_type[opno] != OP_OUT)
|
&& opno != eopno
|
&& opno != eopno
|
/* Ignore things like match_operator operands. */
|
/* Ignore things like match_operator operands. */
|
&& *recog_data.constraints[opno] != 0
|
&& *recog_data.constraints[opno] != 0
|
&& ! (matching_operands[opno] == eopno
|
&& ! (matching_operands[opno] == eopno
|
&& operands_match_p (recog_data.operand[opno],
|
&& operands_match_p (recog_data.operand[opno],
|
recog_data.operand[eopno]))
|
recog_data.operand[eopno]))
|
&& ! safe_from_earlyclobber (recog_data.operand[opno],
|
&& ! safe_from_earlyclobber (recog_data.operand[opno],
|
recog_data.operand[eopno]))
|
recog_data.operand[eopno]))
|
lose = 1;
|
lose = 1;
|
|
|
if (! lose)
|
if (! lose)
|
{
|
{
|
while (--funny_match_index >= 0)
|
while (--funny_match_index >= 0)
|
{
|
{
|
recog_data.operand[funny_match[funny_match_index].other]
|
recog_data.operand[funny_match[funny_match_index].other]
|
= recog_data.operand[funny_match[funny_match_index].this];
|
= recog_data.operand[funny_match[funny_match_index].this];
|
}
|
}
|
|
|
return 1;
|
return 1;
|
}
|
}
|
}
|
}
|
|
|
which_alternative++;
|
which_alternative++;
|
}
|
}
|
while (which_alternative < recog_data.n_alternatives);
|
while (which_alternative < recog_data.n_alternatives);
|
|
|
which_alternative = -1;
|
which_alternative = -1;
|
/* If we are about to reject this, but we are not to test strictly,
|
/* If we are about to reject this, but we are not to test strictly,
|
try a very loose test. Only return failure if it fails also. */
|
try a very loose test. Only return failure if it fails also. */
|
if (strict == 0)
|
if (strict == 0)
|
return constrain_operands (-1);
|
return constrain_operands (-1);
|
else
|
else
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Return 1 iff OPERAND (assumed to be a REG rtx)
|
/* Return 1 iff OPERAND (assumed to be a REG rtx)
|
is a hard reg in class CLASS when its regno is offset by OFFSET
|
is a hard reg in class CLASS when its regno is offset by OFFSET
|
and changed to mode MODE.
|
and changed to mode MODE.
|
If REG occupies multiple hard regs, all of them must be in CLASS. */
|
If REG occupies multiple hard regs, all of them must be in CLASS. */
|
|
|
int
|
int
|
reg_fits_class_p (rtx operand, enum reg_class cl, int offset,
|
reg_fits_class_p (rtx operand, enum reg_class cl, int offset,
|
enum machine_mode mode)
|
enum machine_mode mode)
|
{
|
{
|
int regno = REGNO (operand);
|
int regno = REGNO (operand);
|
|
|
if (cl == NO_REGS)
|
if (cl == NO_REGS)
|
return 0;
|
return 0;
|
|
|
if (regno < FIRST_PSEUDO_REGISTER
|
if (regno < FIRST_PSEUDO_REGISTER
|
&& TEST_HARD_REG_BIT (reg_class_contents[(int) cl],
|
&& TEST_HARD_REG_BIT (reg_class_contents[(int) cl],
|
regno + offset))
|
regno + offset))
|
{
|
{
|
int sr;
|
int sr;
|
regno += offset;
|
regno += offset;
|
for (sr = hard_regno_nregs[regno][mode] - 1;
|
for (sr = hard_regno_nregs[regno][mode] - 1;
|
sr > 0; sr--)
|
sr > 0; sr--)
|
if (! TEST_HARD_REG_BIT (reg_class_contents[(int) cl],
|
if (! TEST_HARD_REG_BIT (reg_class_contents[(int) cl],
|
regno + sr))
|
regno + sr))
|
break;
|
break;
|
return sr == 0;
|
return sr == 0;
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Split single instruction. Helper function for split_all_insns and
|
/* Split single instruction. Helper function for split_all_insns and
|
split_all_insns_noflow. Return last insn in the sequence if successful,
|
split_all_insns_noflow. Return last insn in the sequence if successful,
|
or NULL if unsuccessful. */
|
or NULL if unsuccessful. */
|
|
|
static rtx
|
static rtx
|
split_insn (rtx insn)
|
split_insn (rtx insn)
|
{
|
{
|
/* Split insns here to get max fine-grain parallelism. */
|
/* Split insns here to get max fine-grain parallelism. */
|
rtx first = PREV_INSN (insn);
|
rtx first = PREV_INSN (insn);
|
rtx last = try_split (PATTERN (insn), insn, 1);
|
rtx last = try_split (PATTERN (insn), insn, 1);
|
|
|
if (last == insn)
|
if (last == insn)
|
return NULL_RTX;
|
return NULL_RTX;
|
|
|
/* try_split returns the NOTE that INSN became. */
|
/* try_split returns the NOTE that INSN became. */
|
SET_INSN_DELETED (insn);
|
SET_INSN_DELETED (insn);
|
|
|
/* ??? Coddle to md files that generate subregs in post-reload
|
/* ??? Coddle to md files that generate subregs in post-reload
|
splitters instead of computing the proper hard register. */
|
splitters instead of computing the proper hard register. */
|
if (reload_completed && first != last)
|
if (reload_completed && first != last)
|
{
|
{
|
first = NEXT_INSN (first);
|
first = NEXT_INSN (first);
|
for (;;)
|
for (;;)
|
{
|
{
|
if (INSN_P (first))
|
if (INSN_P (first))
|
cleanup_subreg_operands (first);
|
cleanup_subreg_operands (first);
|
if (first == last)
|
if (first == last)
|
break;
|
break;
|
first = NEXT_INSN (first);
|
first = NEXT_INSN (first);
|
}
|
}
|
}
|
}
|
return last;
|
return last;
|
}
|
}
|
|
|
/* Split all insns in the function. If UPD_LIFE, update life info after. */
|
/* Split all insns in the function. If UPD_LIFE, update life info after. */
|
|
|
void
|
void
|
split_all_insns (int upd_life)
|
split_all_insns (int upd_life)
|
{
|
{
|
sbitmap blocks;
|
sbitmap blocks;
|
bool changed;
|
bool changed;
|
basic_block bb;
|
basic_block bb;
|
|
|
blocks = sbitmap_alloc (last_basic_block);
|
blocks = sbitmap_alloc (last_basic_block);
|
sbitmap_zero (blocks);
|
sbitmap_zero (blocks);
|
changed = false;
|
changed = false;
|
|
|
FOR_EACH_BB_REVERSE (bb)
|
FOR_EACH_BB_REVERSE (bb)
|
{
|
{
|
rtx insn, next;
|
rtx insn, next;
|
bool finish = false;
|
bool finish = false;
|
|
|
for (insn = BB_HEAD (bb); !finish ; insn = next)
|
for (insn = BB_HEAD (bb); !finish ; insn = next)
|
{
|
{
|
/* Can't use `next_real_insn' because that might go across
|
/* Can't use `next_real_insn' because that might go across
|
CODE_LABELS and short-out basic blocks. */
|
CODE_LABELS and short-out basic blocks. */
|
next = NEXT_INSN (insn);
|
next = NEXT_INSN (insn);
|
finish = (insn == BB_END (bb));
|
finish = (insn == BB_END (bb));
|
if (INSN_P (insn))
|
if (INSN_P (insn))
|
{
|
{
|
rtx set = single_set (insn);
|
rtx set = single_set (insn);
|
|
|
/* Don't split no-op move insns. These should silently
|
/* Don't split no-op move insns. These should silently
|
disappear later in final. Splitting such insns would
|
disappear later in final. Splitting such insns would
|
break the code that handles REG_NO_CONFLICT blocks. */
|
break the code that handles REG_NO_CONFLICT blocks. */
|
if (set && set_noop_p (set))
|
if (set && set_noop_p (set))
|
{
|
{
|
/* Nops get in the way while scheduling, so delete them
|
/* Nops get in the way while scheduling, so delete them
|
now if register allocation has already been done. It
|
now if register allocation has already been done. It
|
is too risky to try to do this before register
|
is too risky to try to do this before register
|
allocation, and there are unlikely to be very many
|
allocation, and there are unlikely to be very many
|
nops then anyways. */
|
nops then anyways. */
|
if (reload_completed)
|
if (reload_completed)
|
{
|
{
|
/* If the no-op set has a REG_UNUSED note, we need
|
/* If the no-op set has a REG_UNUSED note, we need
|
to update liveness information. */
|
to update liveness information. */
|
if (find_reg_note (insn, REG_UNUSED, NULL_RTX))
|
if (find_reg_note (insn, REG_UNUSED, NULL_RTX))
|
{
|
{
|
SET_BIT (blocks, bb->index);
|
SET_BIT (blocks, bb->index);
|
changed = true;
|
changed = true;
|
}
|
}
|
/* ??? Is life info affected by deleting edges? */
|
/* ??? Is life info affected by deleting edges? */
|
delete_insn_and_edges (insn);
|
delete_insn_and_edges (insn);
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
rtx last = split_insn (insn);
|
rtx last = split_insn (insn);
|
if (last)
|
if (last)
|
{
|
{
|
/* The split sequence may include barrier, but the
|
/* The split sequence may include barrier, but the
|
BB boundary we are interested in will be set to
|
BB boundary we are interested in will be set to
|
previous one. */
|
previous one. */
|
|
|
while (BARRIER_P (last))
|
while (BARRIER_P (last))
|
last = PREV_INSN (last);
|
last = PREV_INSN (last);
|
SET_BIT (blocks, bb->index);
|
SET_BIT (blocks, bb->index);
|
changed = true;
|
changed = true;
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
if (changed)
|
if (changed)
|
{
|
{
|
int old_last_basic_block = last_basic_block;
|
int old_last_basic_block = last_basic_block;
|
|
|
find_many_sub_basic_blocks (blocks);
|
find_many_sub_basic_blocks (blocks);
|
|
|
if (old_last_basic_block != last_basic_block && upd_life)
|
if (old_last_basic_block != last_basic_block && upd_life)
|
blocks = sbitmap_resize (blocks, last_basic_block, 1);
|
blocks = sbitmap_resize (blocks, last_basic_block, 1);
|
}
|
}
|
|
|
if (changed && upd_life)
|
if (changed && upd_life)
|
update_life_info (blocks, UPDATE_LIFE_GLOBAL_RM_NOTES,
|
update_life_info (blocks, UPDATE_LIFE_GLOBAL_RM_NOTES,
|
PROP_DEATH_NOTES);
|
PROP_DEATH_NOTES);
|
|
|
#ifdef ENABLE_CHECKING
|
#ifdef ENABLE_CHECKING
|
verify_flow_info ();
|
verify_flow_info ();
|
#endif
|
#endif
|
|
|
sbitmap_free (blocks);
|
sbitmap_free (blocks);
|
}
|
}
|
|
|
/* Same as split_all_insns, but do not expect CFG to be available.
|
/* Same as split_all_insns, but do not expect CFG to be available.
|
Used by machine dependent reorg passes. */
|
Used by machine dependent reorg passes. */
|
|
|
unsigned int
|
unsigned int
|
split_all_insns_noflow (void)
|
split_all_insns_noflow (void)
|
{
|
{
|
rtx next, insn;
|
rtx next, insn;
|
|
|
for (insn = get_insns (); insn; insn = next)
|
for (insn = get_insns (); insn; insn = next)
|
{
|
{
|
next = NEXT_INSN (insn);
|
next = NEXT_INSN (insn);
|
if (INSN_P (insn))
|
if (INSN_P (insn))
|
{
|
{
|
/* Don't split no-op move insns. These should silently
|
/* Don't split no-op move insns. These should silently
|
disappear later in final. Splitting such insns would
|
disappear later in final. Splitting such insns would
|
break the code that handles REG_NO_CONFLICT blocks. */
|
break the code that handles REG_NO_CONFLICT blocks. */
|
rtx set = single_set (insn);
|
rtx set = single_set (insn);
|
if (set && set_noop_p (set))
|
if (set && set_noop_p (set))
|
{
|
{
|
/* Nops get in the way while scheduling, so delete them
|
/* Nops get in the way while scheduling, so delete them
|
now if register allocation has already been done. It
|
now if register allocation has already been done. It
|
is too risky to try to do this before register
|
is too risky to try to do this before register
|
allocation, and there are unlikely to be very many
|
allocation, and there are unlikely to be very many
|
nops then anyways.
|
nops then anyways.
|
|
|
??? Should we use delete_insn when the CFG isn't valid? */
|
??? Should we use delete_insn when the CFG isn't valid? */
|
if (reload_completed)
|
if (reload_completed)
|
delete_insn_and_edges (insn);
|
delete_insn_and_edges (insn);
|
}
|
}
|
else
|
else
|
split_insn (insn);
|
split_insn (insn);
|
}
|
}
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
#ifdef HAVE_peephole2
|
#ifdef HAVE_peephole2
|
struct peep2_insn_data
|
struct peep2_insn_data
|
{
|
{
|
rtx insn;
|
rtx insn;
|
regset live_before;
|
regset live_before;
|
};
|
};
|
|
|
static struct peep2_insn_data peep2_insn_data[MAX_INSNS_PER_PEEP2 + 1];
|
static struct peep2_insn_data peep2_insn_data[MAX_INSNS_PER_PEEP2 + 1];
|
static int peep2_current;
|
static int peep2_current;
|
/* The number of instructions available to match a peep2. */
|
/* The number of instructions available to match a peep2. */
|
int peep2_current_count;
|
int peep2_current_count;
|
|
|
/* A non-insn marker indicating the last insn of the block.
|
/* A non-insn marker indicating the last insn of the block.
|
The live_before regset for this element is correct, indicating
|
The live_before regset for this element is correct, indicating
|
global_live_at_end for the block. */
|
global_live_at_end for the block. */
|
#define PEEP2_EOB pc_rtx
|
#define PEEP2_EOB pc_rtx
|
|
|
/* Return the Nth non-note insn after `current', or return NULL_RTX if it
|
/* Return the Nth non-note insn after `current', or return NULL_RTX if it
|
does not exist. Used by the recognizer to find the next insn to match
|
does not exist. Used by the recognizer to find the next insn to match
|
in a multi-insn pattern. */
|
in a multi-insn pattern. */
|
|
|
rtx
|
rtx
|
peep2_next_insn (int n)
|
peep2_next_insn (int n)
|
{
|
{
|
gcc_assert (n <= peep2_current_count);
|
gcc_assert (n <= peep2_current_count);
|
|
|
n += peep2_current;
|
n += peep2_current;
|
if (n >= MAX_INSNS_PER_PEEP2 + 1)
|
if (n >= MAX_INSNS_PER_PEEP2 + 1)
|
n -= MAX_INSNS_PER_PEEP2 + 1;
|
n -= MAX_INSNS_PER_PEEP2 + 1;
|
|
|
return peep2_insn_data[n].insn;
|
return peep2_insn_data[n].insn;
|
}
|
}
|
|
|
/* Return true if REGNO is dead before the Nth non-note insn
|
/* Return true if REGNO is dead before the Nth non-note insn
|
after `current'. */
|
after `current'. */
|
|
|
int
|
int
|
peep2_regno_dead_p (int ofs, int regno)
|
peep2_regno_dead_p (int ofs, int regno)
|
{
|
{
|
gcc_assert (ofs < MAX_INSNS_PER_PEEP2 + 1);
|
gcc_assert (ofs < MAX_INSNS_PER_PEEP2 + 1);
|
|
|
ofs += peep2_current;
|
ofs += peep2_current;
|
if (ofs >= MAX_INSNS_PER_PEEP2 + 1)
|
if (ofs >= MAX_INSNS_PER_PEEP2 + 1)
|
ofs -= MAX_INSNS_PER_PEEP2 + 1;
|
ofs -= MAX_INSNS_PER_PEEP2 + 1;
|
|
|
gcc_assert (peep2_insn_data[ofs].insn != NULL_RTX);
|
gcc_assert (peep2_insn_data[ofs].insn != NULL_RTX);
|
|
|
return ! REGNO_REG_SET_P (peep2_insn_data[ofs].live_before, regno);
|
return ! REGNO_REG_SET_P (peep2_insn_data[ofs].live_before, regno);
|
}
|
}
|
|
|
/* Similarly for a REG. */
|
/* Similarly for a REG. */
|
|
|
int
|
int
|
peep2_reg_dead_p (int ofs, rtx reg)
|
peep2_reg_dead_p (int ofs, rtx reg)
|
{
|
{
|
int regno, n;
|
int regno, n;
|
|
|
gcc_assert (ofs < MAX_INSNS_PER_PEEP2 + 1);
|
gcc_assert (ofs < MAX_INSNS_PER_PEEP2 + 1);
|
|
|
ofs += peep2_current;
|
ofs += peep2_current;
|
if (ofs >= MAX_INSNS_PER_PEEP2 + 1)
|
if (ofs >= MAX_INSNS_PER_PEEP2 + 1)
|
ofs -= MAX_INSNS_PER_PEEP2 + 1;
|
ofs -= MAX_INSNS_PER_PEEP2 + 1;
|
|
|
gcc_assert (peep2_insn_data[ofs].insn != NULL_RTX);
|
gcc_assert (peep2_insn_data[ofs].insn != NULL_RTX);
|
|
|
regno = REGNO (reg);
|
regno = REGNO (reg);
|
n = hard_regno_nregs[regno][GET_MODE (reg)];
|
n = hard_regno_nregs[regno][GET_MODE (reg)];
|
while (--n >= 0)
|
while (--n >= 0)
|
if (REGNO_REG_SET_P (peep2_insn_data[ofs].live_before, regno + n))
|
if (REGNO_REG_SET_P (peep2_insn_data[ofs].live_before, regno + n))
|
return 0;
|
return 0;
|
return 1;
|
return 1;
|
}
|
}
|
|
|
/* Try to find a hard register of mode MODE, matching the register class in
|
/* Try to find a hard register of mode MODE, matching the register class in
|
CLASS_STR, which is available at the beginning of insn CURRENT_INSN and
|
CLASS_STR, which is available at the beginning of insn CURRENT_INSN and
|
remains available until the end of LAST_INSN. LAST_INSN may be NULL_RTX,
|
remains available until the end of LAST_INSN. LAST_INSN may be NULL_RTX,
|
in which case the only condition is that the register must be available
|
in which case the only condition is that the register must be available
|
before CURRENT_INSN.
|
before CURRENT_INSN.
|
Registers that already have bits set in REG_SET will not be considered.
|
Registers that already have bits set in REG_SET will not be considered.
|
|
|
If an appropriate register is available, it will be returned and the
|
If an appropriate register is available, it will be returned and the
|
corresponding bit(s) in REG_SET will be set; otherwise, NULL_RTX is
|
corresponding bit(s) in REG_SET will be set; otherwise, NULL_RTX is
|
returned. */
|
returned. */
|
|
|
rtx
|
rtx
|
peep2_find_free_register (int from, int to, const char *class_str,
|
peep2_find_free_register (int from, int to, const char *class_str,
|
enum machine_mode mode, HARD_REG_SET *reg_set)
|
enum machine_mode mode, HARD_REG_SET *reg_set)
|
{
|
{
|
static int search_ofs;
|
static int search_ofs;
|
enum reg_class cl;
|
enum reg_class cl;
|
HARD_REG_SET live;
|
HARD_REG_SET live;
|
int i;
|
int i;
|
|
|
gcc_assert (from < MAX_INSNS_PER_PEEP2 + 1);
|
gcc_assert (from < MAX_INSNS_PER_PEEP2 + 1);
|
gcc_assert (to < MAX_INSNS_PER_PEEP2 + 1);
|
gcc_assert (to < MAX_INSNS_PER_PEEP2 + 1);
|
|
|
from += peep2_current;
|
from += peep2_current;
|
if (from >= MAX_INSNS_PER_PEEP2 + 1)
|
if (from >= MAX_INSNS_PER_PEEP2 + 1)
|
from -= MAX_INSNS_PER_PEEP2 + 1;
|
from -= MAX_INSNS_PER_PEEP2 + 1;
|
to += peep2_current;
|
to += peep2_current;
|
if (to >= MAX_INSNS_PER_PEEP2 + 1)
|
if (to >= MAX_INSNS_PER_PEEP2 + 1)
|
to -= MAX_INSNS_PER_PEEP2 + 1;
|
to -= MAX_INSNS_PER_PEEP2 + 1;
|
|
|
gcc_assert (peep2_insn_data[from].insn != NULL_RTX);
|
gcc_assert (peep2_insn_data[from].insn != NULL_RTX);
|
REG_SET_TO_HARD_REG_SET (live, peep2_insn_data[from].live_before);
|
REG_SET_TO_HARD_REG_SET (live, peep2_insn_data[from].live_before);
|
|
|
while (from != to)
|
while (from != to)
|
{
|
{
|
HARD_REG_SET this_live;
|
HARD_REG_SET this_live;
|
|
|
if (++from >= MAX_INSNS_PER_PEEP2 + 1)
|
if (++from >= MAX_INSNS_PER_PEEP2 + 1)
|
from = 0;
|
from = 0;
|
gcc_assert (peep2_insn_data[from].insn != NULL_RTX);
|
gcc_assert (peep2_insn_data[from].insn != NULL_RTX);
|
REG_SET_TO_HARD_REG_SET (this_live, peep2_insn_data[from].live_before);
|
REG_SET_TO_HARD_REG_SET (this_live, peep2_insn_data[from].live_before);
|
IOR_HARD_REG_SET (live, this_live);
|
IOR_HARD_REG_SET (live, this_live);
|
}
|
}
|
|
|
cl = (class_str[0] == 'r' ? GENERAL_REGS
|
cl = (class_str[0] == 'r' ? GENERAL_REGS
|
: REG_CLASS_FROM_CONSTRAINT (class_str[0], class_str));
|
: REG_CLASS_FROM_CONSTRAINT (class_str[0], class_str));
|
|
|
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
|
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
|
{
|
{
|
int raw_regno, regno, success, j;
|
int raw_regno, regno, success, j;
|
|
|
/* Distribute the free registers as much as possible. */
|
/* Distribute the free registers as much as possible. */
|
raw_regno = search_ofs + i;
|
raw_regno = search_ofs + i;
|
if (raw_regno >= FIRST_PSEUDO_REGISTER)
|
if (raw_regno >= FIRST_PSEUDO_REGISTER)
|
raw_regno -= FIRST_PSEUDO_REGISTER;
|
raw_regno -= FIRST_PSEUDO_REGISTER;
|
#ifdef REG_ALLOC_ORDER
|
#ifdef REG_ALLOC_ORDER
|
regno = reg_alloc_order[raw_regno];
|
regno = reg_alloc_order[raw_regno];
|
#else
|
#else
|
regno = raw_regno;
|
regno = raw_regno;
|
#endif
|
#endif
|
|
|
/* Don't allocate fixed registers. */
|
/* Don't allocate fixed registers. */
|
if (fixed_regs[regno])
|
if (fixed_regs[regno])
|
continue;
|
continue;
|
/* Make sure the register is of the right class. */
|
/* Make sure the register is of the right class. */
|
if (! TEST_HARD_REG_BIT (reg_class_contents[cl], regno))
|
if (! TEST_HARD_REG_BIT (reg_class_contents[cl], regno))
|
continue;
|
continue;
|
/* And can support the mode we need. */
|
/* And can support the mode we need. */
|
if (! HARD_REGNO_MODE_OK (regno, mode))
|
if (! HARD_REGNO_MODE_OK (regno, mode))
|
continue;
|
continue;
|
/* And that we don't create an extra save/restore. */
|
/* And that we don't create an extra save/restore. */
|
if (! call_used_regs[regno] && ! regs_ever_live[regno])
|
if (! call_used_regs[regno] && ! regs_ever_live[regno])
|
continue;
|
continue;
|
/* And we don't clobber traceback for noreturn functions. */
|
/* And we don't clobber traceback for noreturn functions. */
|
if ((regno == FRAME_POINTER_REGNUM || regno == HARD_FRAME_POINTER_REGNUM)
|
if ((regno == FRAME_POINTER_REGNUM || regno == HARD_FRAME_POINTER_REGNUM)
|
&& (! reload_completed || frame_pointer_needed))
|
&& (! reload_completed || frame_pointer_needed))
|
continue;
|
continue;
|
|
|
success = 1;
|
success = 1;
|
for (j = hard_regno_nregs[regno][mode] - 1; j >= 0; j--)
|
for (j = hard_regno_nregs[regno][mode] - 1; j >= 0; j--)
|
{
|
{
|
if (TEST_HARD_REG_BIT (*reg_set, regno + j)
|
if (TEST_HARD_REG_BIT (*reg_set, regno + j)
|
|| TEST_HARD_REG_BIT (live, regno + j))
|
|| TEST_HARD_REG_BIT (live, regno + j))
|
{
|
{
|
success = 0;
|
success = 0;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
if (success)
|
if (success)
|
{
|
{
|
for (j = hard_regno_nregs[regno][mode] - 1; j >= 0; j--)
|
for (j = hard_regno_nregs[regno][mode] - 1; j >= 0; j--)
|
SET_HARD_REG_BIT (*reg_set, regno + j);
|
SET_HARD_REG_BIT (*reg_set, regno + j);
|
|
|
/* Start the next search with the next register. */
|
/* Start the next search with the next register. */
|
if (++raw_regno >= FIRST_PSEUDO_REGISTER)
|
if (++raw_regno >= FIRST_PSEUDO_REGISTER)
|
raw_regno = 0;
|
raw_regno = 0;
|
search_ofs = raw_regno;
|
search_ofs = raw_regno;
|
|
|
return gen_rtx_REG (mode, regno);
|
return gen_rtx_REG (mode, regno);
|
}
|
}
|
}
|
}
|
|
|
search_ofs = 0;
|
search_ofs = 0;
|
return NULL_RTX;
|
return NULL_RTX;
|
}
|
}
|
|
|
/* Perform the peephole2 optimization pass. */
|
/* Perform the peephole2 optimization pass. */
|
|
|
static void
|
static void
|
peephole2_optimize (void)
|
peephole2_optimize (void)
|
{
|
{
|
rtx insn, prev;
|
rtx insn, prev;
|
regset live;
|
regset live;
|
int i;
|
int i;
|
basic_block bb;
|
basic_block bb;
|
#ifdef HAVE_conditional_execution
|
#ifdef HAVE_conditional_execution
|
sbitmap blocks;
|
sbitmap blocks;
|
bool changed;
|
bool changed;
|
#endif
|
#endif
|
bool do_cleanup_cfg = false;
|
bool do_cleanup_cfg = false;
|
bool do_global_life_update = false;
|
bool do_global_life_update = false;
|
bool do_rebuild_jump_labels = false;
|
bool do_rebuild_jump_labels = false;
|
|
|
/* Initialize the regsets we're going to use. */
|
/* Initialize the regsets we're going to use. */
|
for (i = 0; i < MAX_INSNS_PER_PEEP2 + 1; ++i)
|
for (i = 0; i < MAX_INSNS_PER_PEEP2 + 1; ++i)
|
peep2_insn_data[i].live_before = ALLOC_REG_SET (®_obstack);
|
peep2_insn_data[i].live_before = ALLOC_REG_SET (®_obstack);
|
live = ALLOC_REG_SET (®_obstack);
|
live = ALLOC_REG_SET (®_obstack);
|
|
|
#ifdef HAVE_conditional_execution
|
#ifdef HAVE_conditional_execution
|
blocks = sbitmap_alloc (last_basic_block);
|
blocks = sbitmap_alloc (last_basic_block);
|
sbitmap_zero (blocks);
|
sbitmap_zero (blocks);
|
changed = false;
|
changed = false;
|
#else
|
#else
|
count_or_remove_death_notes (NULL, 1);
|
count_or_remove_death_notes (NULL, 1);
|
#endif
|
#endif
|
|
|
FOR_EACH_BB_REVERSE (bb)
|
FOR_EACH_BB_REVERSE (bb)
|
{
|
{
|
struct propagate_block_info *pbi;
|
struct propagate_block_info *pbi;
|
reg_set_iterator rsi;
|
reg_set_iterator rsi;
|
unsigned int j;
|
unsigned int j;
|
|
|
/* Indicate that all slots except the last holds invalid data. */
|
/* Indicate that all slots except the last holds invalid data. */
|
for (i = 0; i < MAX_INSNS_PER_PEEP2; ++i)
|
for (i = 0; i < MAX_INSNS_PER_PEEP2; ++i)
|
peep2_insn_data[i].insn = NULL_RTX;
|
peep2_insn_data[i].insn = NULL_RTX;
|
peep2_current_count = 0;
|
peep2_current_count = 0;
|
|
|
/* Indicate that the last slot contains live_after data. */
|
/* Indicate that the last slot contains live_after data. */
|
peep2_insn_data[MAX_INSNS_PER_PEEP2].insn = PEEP2_EOB;
|
peep2_insn_data[MAX_INSNS_PER_PEEP2].insn = PEEP2_EOB;
|
peep2_current = MAX_INSNS_PER_PEEP2;
|
peep2_current = MAX_INSNS_PER_PEEP2;
|
|
|
/* Start up propagation. */
|
/* Start up propagation. */
|
COPY_REG_SET (live, bb->il.rtl->global_live_at_end);
|
COPY_REG_SET (live, bb->il.rtl->global_live_at_end);
|
COPY_REG_SET (peep2_insn_data[MAX_INSNS_PER_PEEP2].live_before, live);
|
COPY_REG_SET (peep2_insn_data[MAX_INSNS_PER_PEEP2].live_before, live);
|
|
|
#ifdef HAVE_conditional_execution
|
#ifdef HAVE_conditional_execution
|
pbi = init_propagate_block_info (bb, live, NULL, NULL, 0);
|
pbi = init_propagate_block_info (bb, live, NULL, NULL, 0);
|
#else
|
#else
|
pbi = init_propagate_block_info (bb, live, NULL, NULL, PROP_DEATH_NOTES);
|
pbi = init_propagate_block_info (bb, live, NULL, NULL, PROP_DEATH_NOTES);
|
#endif
|
#endif
|
|
|
for (insn = BB_END (bb); ; insn = prev)
|
for (insn = BB_END (bb); ; insn = prev)
|
{
|
{
|
prev = PREV_INSN (insn);
|
prev = PREV_INSN (insn);
|
if (INSN_P (insn))
|
if (INSN_P (insn))
|
{
|
{
|
rtx try, before_try, x;
|
rtx try, before_try, x;
|
int match_len;
|
int match_len;
|
rtx note;
|
rtx note;
|
bool was_call = false;
|
bool was_call = false;
|
|
|
/* Record this insn. */
|
/* Record this insn. */
|
if (--peep2_current < 0)
|
if (--peep2_current < 0)
|
peep2_current = MAX_INSNS_PER_PEEP2;
|
peep2_current = MAX_INSNS_PER_PEEP2;
|
if (peep2_current_count < MAX_INSNS_PER_PEEP2
|
if (peep2_current_count < MAX_INSNS_PER_PEEP2
|
&& peep2_insn_data[peep2_current].insn == NULL_RTX)
|
&& peep2_insn_data[peep2_current].insn == NULL_RTX)
|
peep2_current_count++;
|
peep2_current_count++;
|
peep2_insn_data[peep2_current].insn = insn;
|
peep2_insn_data[peep2_current].insn = insn;
|
propagate_one_insn (pbi, insn);
|
propagate_one_insn (pbi, insn);
|
COPY_REG_SET (peep2_insn_data[peep2_current].live_before, live);
|
COPY_REG_SET (peep2_insn_data[peep2_current].live_before, live);
|
|
|
if (RTX_FRAME_RELATED_P (insn))
|
if (RTX_FRAME_RELATED_P (insn))
|
{
|
{
|
/* If an insn has RTX_FRAME_RELATED_P set, peephole
|
/* If an insn has RTX_FRAME_RELATED_P set, peephole
|
substitution would lose the
|
substitution would lose the
|
REG_FRAME_RELATED_EXPR that is attached. */
|
REG_FRAME_RELATED_EXPR that is attached. */
|
peep2_current_count = 0;
|
peep2_current_count = 0;
|
try = NULL;
|
try = NULL;
|
}
|
}
|
else
|
else
|
/* Match the peephole. */
|
/* Match the peephole. */
|
try = peephole2_insns (PATTERN (insn), insn, &match_len);
|
try = peephole2_insns (PATTERN (insn), insn, &match_len);
|
|
|
if (try != NULL)
|
if (try != NULL)
|
{
|
{
|
/* If we are splitting a CALL_INSN, look for the CALL_INSN
|
/* If we are splitting a CALL_INSN, look for the CALL_INSN
|
in SEQ and copy our CALL_INSN_FUNCTION_USAGE and other
|
in SEQ and copy our CALL_INSN_FUNCTION_USAGE and other
|
cfg-related call notes. */
|
cfg-related call notes. */
|
for (i = 0; i <= match_len; ++i)
|
for (i = 0; i <= match_len; ++i)
|
{
|
{
|
int j;
|
int j;
|
rtx old_insn, new_insn, note;
|
rtx old_insn, new_insn, note;
|
|
|
j = i + peep2_current;
|
j = i + peep2_current;
|
if (j >= MAX_INSNS_PER_PEEP2 + 1)
|
if (j >= MAX_INSNS_PER_PEEP2 + 1)
|
j -= MAX_INSNS_PER_PEEP2 + 1;
|
j -= MAX_INSNS_PER_PEEP2 + 1;
|
old_insn = peep2_insn_data[j].insn;
|
old_insn = peep2_insn_data[j].insn;
|
if (!CALL_P (old_insn))
|
if (!CALL_P (old_insn))
|
continue;
|
continue;
|
was_call = true;
|
was_call = true;
|
|
|
new_insn = try;
|
new_insn = try;
|
while (new_insn != NULL_RTX)
|
while (new_insn != NULL_RTX)
|
{
|
{
|
if (CALL_P (new_insn))
|
if (CALL_P (new_insn))
|
break;
|
break;
|
new_insn = NEXT_INSN (new_insn);
|
new_insn = NEXT_INSN (new_insn);
|
}
|
}
|
|
|
gcc_assert (new_insn != NULL_RTX);
|
gcc_assert (new_insn != NULL_RTX);
|
|
|
CALL_INSN_FUNCTION_USAGE (new_insn)
|
CALL_INSN_FUNCTION_USAGE (new_insn)
|
= CALL_INSN_FUNCTION_USAGE (old_insn);
|
= CALL_INSN_FUNCTION_USAGE (old_insn);
|
|
|
for (note = REG_NOTES (old_insn);
|
for (note = REG_NOTES (old_insn);
|
note;
|
note;
|
note = XEXP (note, 1))
|
note = XEXP (note, 1))
|
switch (REG_NOTE_KIND (note))
|
switch (REG_NOTE_KIND (note))
|
{
|
{
|
case REG_NORETURN:
|
case REG_NORETURN:
|
case REG_SETJMP:
|
case REG_SETJMP:
|
REG_NOTES (new_insn)
|
REG_NOTES (new_insn)
|
= gen_rtx_EXPR_LIST (REG_NOTE_KIND (note),
|
= gen_rtx_EXPR_LIST (REG_NOTE_KIND (note),
|
XEXP (note, 0),
|
XEXP (note, 0),
|
REG_NOTES (new_insn));
|
REG_NOTES (new_insn));
|
default:
|
default:
|
/* Discard all other reg notes. */
|
/* Discard all other reg notes. */
|
break;
|
break;
|
}
|
}
|
|
|
/* Croak if there is another call in the sequence. */
|
/* Croak if there is another call in the sequence. */
|
while (++i <= match_len)
|
while (++i <= match_len)
|
{
|
{
|
j = i + peep2_current;
|
j = i + peep2_current;
|
if (j >= MAX_INSNS_PER_PEEP2 + 1)
|
if (j >= MAX_INSNS_PER_PEEP2 + 1)
|
j -= MAX_INSNS_PER_PEEP2 + 1;
|
j -= MAX_INSNS_PER_PEEP2 + 1;
|
old_insn = peep2_insn_data[j].insn;
|
old_insn = peep2_insn_data[j].insn;
|
gcc_assert (!CALL_P (old_insn));
|
gcc_assert (!CALL_P (old_insn));
|
}
|
}
|
break;
|
break;
|
}
|
}
|
|
|
i = match_len + peep2_current;
|
i = match_len + peep2_current;
|
if (i >= MAX_INSNS_PER_PEEP2 + 1)
|
if (i >= MAX_INSNS_PER_PEEP2 + 1)
|
i -= MAX_INSNS_PER_PEEP2 + 1;
|
i -= MAX_INSNS_PER_PEEP2 + 1;
|
|
|
note = find_reg_note (peep2_insn_data[i].insn,
|
note = find_reg_note (peep2_insn_data[i].insn,
|
REG_EH_REGION, NULL_RTX);
|
REG_EH_REGION, NULL_RTX);
|
|
|
/* Replace the old sequence with the new. */
|
/* Replace the old sequence with the new. */
|
try = emit_insn_after_setloc (try, peep2_insn_data[i].insn,
|
try = emit_insn_after_setloc (try, peep2_insn_data[i].insn,
|
INSN_LOCATOR (peep2_insn_data[i].insn));
|
INSN_LOCATOR (peep2_insn_data[i].insn));
|
before_try = PREV_INSN (insn);
|
before_try = PREV_INSN (insn);
|
delete_insn_chain (insn, peep2_insn_data[i].insn);
|
delete_insn_chain (insn, peep2_insn_data[i].insn);
|
|
|
/* Re-insert the EH_REGION notes. */
|
/* Re-insert the EH_REGION notes. */
|
if (note || (was_call && nonlocal_goto_handler_labels))
|
if (note || (was_call && nonlocal_goto_handler_labels))
|
{
|
{
|
edge eh_edge;
|
edge eh_edge;
|
edge_iterator ei;
|
edge_iterator ei;
|
|
|
FOR_EACH_EDGE (eh_edge, ei, bb->succs)
|
FOR_EACH_EDGE (eh_edge, ei, bb->succs)
|
if (eh_edge->flags & (EDGE_EH | EDGE_ABNORMAL_CALL))
|
if (eh_edge->flags & (EDGE_EH | EDGE_ABNORMAL_CALL))
|
break;
|
break;
|
|
|
for (x = try ; x != before_try ; x = PREV_INSN (x))
|
for (x = try ; x != before_try ; x = PREV_INSN (x))
|
if (CALL_P (x)
|
if (CALL_P (x)
|
|| (flag_non_call_exceptions
|
|| (flag_non_call_exceptions
|
&& may_trap_p (PATTERN (x))
|
&& may_trap_p (PATTERN (x))
|
&& !find_reg_note (x, REG_EH_REGION, NULL)))
|
&& !find_reg_note (x, REG_EH_REGION, NULL)))
|
{
|
{
|
if (note)
|
if (note)
|
REG_NOTES (x)
|
REG_NOTES (x)
|
= gen_rtx_EXPR_LIST (REG_EH_REGION,
|
= gen_rtx_EXPR_LIST (REG_EH_REGION,
|
XEXP (note, 0),
|
XEXP (note, 0),
|
REG_NOTES (x));
|
REG_NOTES (x));
|
|
|
if (x != BB_END (bb) && eh_edge)
|
if (x != BB_END (bb) && eh_edge)
|
{
|
{
|
edge nfte, nehe;
|
edge nfte, nehe;
|
int flags;
|
int flags;
|
|
|
nfte = split_block (bb, x);
|
nfte = split_block (bb, x);
|
flags = (eh_edge->flags
|
flags = (eh_edge->flags
|
& (EDGE_EH | EDGE_ABNORMAL));
|
& (EDGE_EH | EDGE_ABNORMAL));
|
if (CALL_P (x))
|
if (CALL_P (x))
|
flags |= EDGE_ABNORMAL_CALL;
|
flags |= EDGE_ABNORMAL_CALL;
|
nehe = make_edge (nfte->src, eh_edge->dest,
|
nehe = make_edge (nfte->src, eh_edge->dest,
|
flags);
|
flags);
|
|
|
nehe->probability = eh_edge->probability;
|
nehe->probability = eh_edge->probability;
|
nfte->probability
|
nfte->probability
|
= REG_BR_PROB_BASE - nehe->probability;
|
= REG_BR_PROB_BASE - nehe->probability;
|
|
|
do_cleanup_cfg |= purge_dead_edges (nfte->dest);
|
do_cleanup_cfg |= purge_dead_edges (nfte->dest);
|
#ifdef HAVE_conditional_execution
|
#ifdef HAVE_conditional_execution
|
SET_BIT (blocks, nfte->dest->index);
|
SET_BIT (blocks, nfte->dest->index);
|
changed = true;
|
changed = true;
|
#endif
|
#endif
|
bb = nfte->src;
|
bb = nfte->src;
|
eh_edge = nehe;
|
eh_edge = nehe;
|
}
|
}
|
}
|
}
|
|
|
/* Converting possibly trapping insn to non-trapping is
|
/* Converting possibly trapping insn to non-trapping is
|
possible. Zap dummy outgoing edges. */
|
possible. Zap dummy outgoing edges. */
|
do_cleanup_cfg |= purge_dead_edges (bb);
|
do_cleanup_cfg |= purge_dead_edges (bb);
|
}
|
}
|
|
|
#ifdef HAVE_conditional_execution
|
#ifdef HAVE_conditional_execution
|
/* With conditional execution, we cannot back up the
|
/* With conditional execution, we cannot back up the
|
live information so easily, since the conditional
|
live information so easily, since the conditional
|
death data structures are not so self-contained.
|
death data structures are not so self-contained.
|
So record that we've made a modification to this
|
So record that we've made a modification to this
|
block and update life information at the end. */
|
block and update life information at the end. */
|
SET_BIT (blocks, bb->index);
|
SET_BIT (blocks, bb->index);
|
changed = true;
|
changed = true;
|
|
|
for (i = 0; i < MAX_INSNS_PER_PEEP2 + 1; ++i)
|
for (i = 0; i < MAX_INSNS_PER_PEEP2 + 1; ++i)
|
peep2_insn_data[i].insn = NULL_RTX;
|
peep2_insn_data[i].insn = NULL_RTX;
|
peep2_insn_data[peep2_current].insn = PEEP2_EOB;
|
peep2_insn_data[peep2_current].insn = PEEP2_EOB;
|
peep2_current_count = 0;
|
peep2_current_count = 0;
|
#else
|
#else
|
/* Back up lifetime information past the end of the
|
/* Back up lifetime information past the end of the
|
newly created sequence. */
|
newly created sequence. */
|
if (++i >= MAX_INSNS_PER_PEEP2 + 1)
|
if (++i >= MAX_INSNS_PER_PEEP2 + 1)
|
i = 0;
|
i = 0;
|
COPY_REG_SET (live, peep2_insn_data[i].live_before);
|
COPY_REG_SET (live, peep2_insn_data[i].live_before);
|
|
|
/* Update life information for the new sequence. */
|
/* Update life information for the new sequence. */
|
x = try;
|
x = try;
|
do
|
do
|
{
|
{
|
if (INSN_P (x))
|
if (INSN_P (x))
|
{
|
{
|
if (--i < 0)
|
if (--i < 0)
|
i = MAX_INSNS_PER_PEEP2;
|
i = MAX_INSNS_PER_PEEP2;
|
if (peep2_current_count < MAX_INSNS_PER_PEEP2
|
if (peep2_current_count < MAX_INSNS_PER_PEEP2
|
&& peep2_insn_data[i].insn == NULL_RTX)
|
&& peep2_insn_data[i].insn == NULL_RTX)
|
peep2_current_count++;
|
peep2_current_count++;
|
peep2_insn_data[i].insn = x;
|
peep2_insn_data[i].insn = x;
|
propagate_one_insn (pbi, x);
|
propagate_one_insn (pbi, x);
|
COPY_REG_SET (peep2_insn_data[i].live_before, live);
|
COPY_REG_SET (peep2_insn_data[i].live_before, live);
|
}
|
}
|
x = PREV_INSN (x);
|
x = PREV_INSN (x);
|
}
|
}
|
while (x != prev);
|
while (x != prev);
|
|
|
/* ??? Should verify that LIVE now matches what we
|
/* ??? Should verify that LIVE now matches what we
|
had before the new sequence. */
|
had before the new sequence. */
|
|
|
peep2_current = i;
|
peep2_current = i;
|
#endif
|
#endif
|
|
|
/* If we generated a jump instruction, it won't have
|
/* If we generated a jump instruction, it won't have
|
JUMP_LABEL set. Recompute after we're done. */
|
JUMP_LABEL set. Recompute after we're done. */
|
for (x = try; x != before_try; x = PREV_INSN (x))
|
for (x = try; x != before_try; x = PREV_INSN (x))
|
if (JUMP_P (x))
|
if (JUMP_P (x))
|
{
|
{
|
do_rebuild_jump_labels = true;
|
do_rebuild_jump_labels = true;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
if (insn == BB_HEAD (bb))
|
if (insn == BB_HEAD (bb))
|
break;
|
break;
|
}
|
}
|
|
|
/* Some peepholes can decide the don't need one or more of their
|
/* Some peepholes can decide the don't need one or more of their
|
inputs. If this happens, local life update is not enough. */
|
inputs. If this happens, local life update is not enough. */
|
EXECUTE_IF_AND_COMPL_IN_BITMAP (bb->il.rtl->global_live_at_start, live,
|
EXECUTE_IF_AND_COMPL_IN_BITMAP (bb->il.rtl->global_live_at_start, live,
|
0, j, rsi)
|
0, j, rsi)
|
{
|
{
|
do_global_life_update = true;
|
do_global_life_update = true;
|
break;
|
break;
|
}
|
}
|
|
|
free_propagate_block_info (pbi);
|
free_propagate_block_info (pbi);
|
}
|
}
|
|
|
for (i = 0; i < MAX_INSNS_PER_PEEP2 + 1; ++i)
|
for (i = 0; i < MAX_INSNS_PER_PEEP2 + 1; ++i)
|
FREE_REG_SET (peep2_insn_data[i].live_before);
|
FREE_REG_SET (peep2_insn_data[i].live_before);
|
FREE_REG_SET (live);
|
FREE_REG_SET (live);
|
|
|
if (do_rebuild_jump_labels)
|
if (do_rebuild_jump_labels)
|
rebuild_jump_labels (get_insns ());
|
rebuild_jump_labels (get_insns ());
|
|
|
/* If we eliminated EH edges, we may be able to merge blocks. Further,
|
/* If we eliminated EH edges, we may be able to merge blocks. Further,
|
we've changed global life since exception handlers are no longer
|
we've changed global life since exception handlers are no longer
|
reachable. */
|
reachable. */
|
if (do_cleanup_cfg)
|
if (do_cleanup_cfg)
|
{
|
{
|
cleanup_cfg (0);
|
cleanup_cfg (0);
|
do_global_life_update = true;
|
do_global_life_update = true;
|
}
|
}
|
if (do_global_life_update)
|
if (do_global_life_update)
|
update_life_info (0, UPDATE_LIFE_GLOBAL_RM_NOTES, PROP_DEATH_NOTES);
|
update_life_info (0, UPDATE_LIFE_GLOBAL_RM_NOTES, PROP_DEATH_NOTES);
|
#ifdef HAVE_conditional_execution
|
#ifdef HAVE_conditional_execution
|
else
|
else
|
{
|
{
|
count_or_remove_death_notes (blocks, 1);
|
count_or_remove_death_notes (blocks, 1);
|
update_life_info (blocks, UPDATE_LIFE_LOCAL, PROP_DEATH_NOTES);
|
update_life_info (blocks, UPDATE_LIFE_LOCAL, PROP_DEATH_NOTES);
|
}
|
}
|
sbitmap_free (blocks);
|
sbitmap_free (blocks);
|
#endif
|
#endif
|
}
|
}
|
#endif /* HAVE_peephole2 */
|
#endif /* HAVE_peephole2 */
|
|
|
/* Common predicates for use with define_bypass. */
|
/* Common predicates for use with define_bypass. */
|
|
|
/* True if the dependency between OUT_INSN and IN_INSN is on the store
|
/* True if the dependency between OUT_INSN and IN_INSN is on the store
|
data not the address operand(s) of the store. IN_INSN must be
|
data not the address operand(s) of the store. IN_INSN must be
|
single_set. OUT_INSN must be either a single_set or a PARALLEL with
|
single_set. OUT_INSN must be either a single_set or a PARALLEL with
|
SETs inside. */
|
SETs inside. */
|
|
|
int
|
int
|
store_data_bypass_p (rtx out_insn, rtx in_insn)
|
store_data_bypass_p (rtx out_insn, rtx in_insn)
|
{
|
{
|
rtx out_set, in_set;
|
rtx out_set, in_set;
|
|
|
in_set = single_set (in_insn);
|
in_set = single_set (in_insn);
|
gcc_assert (in_set);
|
gcc_assert (in_set);
|
|
|
if (!MEM_P (SET_DEST (in_set)))
|
if (!MEM_P (SET_DEST (in_set)))
|
return false;
|
return false;
|
|
|
out_set = single_set (out_insn);
|
out_set = single_set (out_insn);
|
if (out_set)
|
if (out_set)
|
{
|
{
|
if (reg_mentioned_p (SET_DEST (out_set), SET_DEST (in_set)))
|
if (reg_mentioned_p (SET_DEST (out_set), SET_DEST (in_set)))
|
return false;
|
return false;
|
}
|
}
|
else
|
else
|
{
|
{
|
rtx out_pat;
|
rtx out_pat;
|
int i;
|
int i;
|
|
|
out_pat = PATTERN (out_insn);
|
out_pat = PATTERN (out_insn);
|
gcc_assert (GET_CODE (out_pat) == PARALLEL);
|
gcc_assert (GET_CODE (out_pat) == PARALLEL);
|
|
|
for (i = 0; i < XVECLEN (out_pat, 0); i++)
|
for (i = 0; i < XVECLEN (out_pat, 0); i++)
|
{
|
{
|
rtx exp = XVECEXP (out_pat, 0, i);
|
rtx exp = XVECEXP (out_pat, 0, i);
|
|
|
if (GET_CODE (exp) == CLOBBER)
|
if (GET_CODE (exp) == CLOBBER)
|
continue;
|
continue;
|
|
|
gcc_assert (GET_CODE (exp) == SET);
|
gcc_assert (GET_CODE (exp) == SET);
|
|
|
if (reg_mentioned_p (SET_DEST (exp), SET_DEST (in_set)))
|
if (reg_mentioned_p (SET_DEST (exp), SET_DEST (in_set)))
|
return false;
|
return false;
|
}
|
}
|
}
|
}
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
/* True if the dependency between OUT_INSN and IN_INSN is in the IF_THEN_ELSE
|
/* True if the dependency between OUT_INSN and IN_INSN is in the IF_THEN_ELSE
|
condition, and not the THEN or ELSE branch. OUT_INSN may be either a single
|
condition, and not the THEN or ELSE branch. OUT_INSN may be either a single
|
or multiple set; IN_INSN should be single_set for truth, but for convenience
|
or multiple set; IN_INSN should be single_set for truth, but for convenience
|
of insn categorization may be any JUMP or CALL insn. */
|
of insn categorization may be any JUMP or CALL insn. */
|
|
|
int
|
int
|
if_test_bypass_p (rtx out_insn, rtx in_insn)
|
if_test_bypass_p (rtx out_insn, rtx in_insn)
|
{
|
{
|
rtx out_set, in_set;
|
rtx out_set, in_set;
|
|
|
in_set = single_set (in_insn);
|
in_set = single_set (in_insn);
|
if (! in_set)
|
if (! in_set)
|
{
|
{
|
gcc_assert (JUMP_P (in_insn) || CALL_P (in_insn));
|
gcc_assert (JUMP_P (in_insn) || CALL_P (in_insn));
|
return false;
|
return false;
|
}
|
}
|
|
|
if (GET_CODE (SET_SRC (in_set)) != IF_THEN_ELSE)
|
if (GET_CODE (SET_SRC (in_set)) != IF_THEN_ELSE)
|
return false;
|
return false;
|
in_set = SET_SRC (in_set);
|
in_set = SET_SRC (in_set);
|
|
|
out_set = single_set (out_insn);
|
out_set = single_set (out_insn);
|
if (out_set)
|
if (out_set)
|
{
|
{
|
if (reg_mentioned_p (SET_DEST (out_set), XEXP (in_set, 1))
|
if (reg_mentioned_p (SET_DEST (out_set), XEXP (in_set, 1))
|
|| reg_mentioned_p (SET_DEST (out_set), XEXP (in_set, 2)))
|
|| reg_mentioned_p (SET_DEST (out_set), XEXP (in_set, 2)))
|
return false;
|
return false;
|
}
|
}
|
else
|
else
|
{
|
{
|
rtx out_pat;
|
rtx out_pat;
|
int i;
|
int i;
|
|
|
out_pat = PATTERN (out_insn);
|
out_pat = PATTERN (out_insn);
|
gcc_assert (GET_CODE (out_pat) == PARALLEL);
|
gcc_assert (GET_CODE (out_pat) == PARALLEL);
|
|
|
for (i = 0; i < XVECLEN (out_pat, 0); i++)
|
for (i = 0; i < XVECLEN (out_pat, 0); i++)
|
{
|
{
|
rtx exp = XVECEXP (out_pat, 0, i);
|
rtx exp = XVECEXP (out_pat, 0, i);
|
|
|
if (GET_CODE (exp) == CLOBBER)
|
if (GET_CODE (exp) == CLOBBER)
|
continue;
|
continue;
|
|
|
gcc_assert (GET_CODE (exp) == SET);
|
gcc_assert (GET_CODE (exp) == SET);
|
|
|
if (reg_mentioned_p (SET_DEST (out_set), XEXP (in_set, 1))
|
if (reg_mentioned_p (SET_DEST (out_set), XEXP (in_set, 1))
|
|| reg_mentioned_p (SET_DEST (out_set), XEXP (in_set, 2)))
|
|| reg_mentioned_p (SET_DEST (out_set), XEXP (in_set, 2)))
|
return false;
|
return false;
|
}
|
}
|
}
|
}
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
static bool
|
static bool
|
gate_handle_peephole2 (void)
|
gate_handle_peephole2 (void)
|
{
|
{
|
return (optimize > 0 && flag_peephole2);
|
return (optimize > 0 && flag_peephole2);
|
}
|
}
|
|
|
static unsigned int
|
static unsigned int
|
rest_of_handle_peephole2 (void)
|
rest_of_handle_peephole2 (void)
|
{
|
{
|
#ifdef HAVE_peephole2
|
#ifdef HAVE_peephole2
|
peephole2_optimize ();
|
peephole2_optimize ();
|
#endif
|
#endif
|
return 0;
|
return 0;
|
}
|
}
|
|
|
struct tree_opt_pass pass_peephole2 =
|
struct tree_opt_pass pass_peephole2 =
|
{
|
{
|
"peephole2", /* name */
|
"peephole2", /* name */
|
gate_handle_peephole2, /* gate */
|
gate_handle_peephole2, /* gate */
|
rest_of_handle_peephole2, /* execute */
|
rest_of_handle_peephole2, /* execute */
|
NULL, /* sub */
|
NULL, /* sub */
|
NULL, /* next */
|
NULL, /* next */
|
0, /* static_pass_number */
|
0, /* static_pass_number */
|
TV_PEEPHOLE2, /* tv_id */
|
TV_PEEPHOLE2, /* tv_id */
|
0, /* properties_required */
|
0, /* properties_required */
|
0, /* properties_provided */
|
0, /* properties_provided */
|
0, /* properties_destroyed */
|
0, /* properties_destroyed */
|
0, /* todo_flags_start */
|
0, /* todo_flags_start */
|
TODO_dump_func, /* todo_flags_finish */
|
TODO_dump_func, /* todo_flags_finish */
|
'z' /* letter */
|
'z' /* letter */
|
};
|
};
|
|
|
static unsigned int
|
static unsigned int
|
rest_of_handle_split_all_insns (void)
|
rest_of_handle_split_all_insns (void)
|
{
|
{
|
split_all_insns (1);
|
split_all_insns (1);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
struct tree_opt_pass pass_split_all_insns =
|
struct tree_opt_pass pass_split_all_insns =
|
{
|
{
|
"split1", /* name */
|
"split1", /* name */
|
NULL, /* gate */
|
NULL, /* gate */
|
rest_of_handle_split_all_insns, /* execute */
|
rest_of_handle_split_all_insns, /* execute */
|
NULL, /* sub */
|
NULL, /* sub */
|
NULL, /* next */
|
NULL, /* next */
|
0, /* static_pass_number */
|
0, /* static_pass_number */
|
0, /* tv_id */
|
0, /* tv_id */
|
0, /* properties_required */
|
0, /* properties_required */
|
0, /* properties_provided */
|
0, /* properties_provided */
|
0, /* properties_destroyed */
|
0, /* properties_destroyed */
|
0, /* todo_flags_start */
|
0, /* todo_flags_start */
|
TODO_dump_func, /* todo_flags_finish */
|
TODO_dump_func, /* todo_flags_finish */
|
0 /* letter */
|
0 /* letter */
|
};
|
};
|
|
|
/* The placement of the splitting that we do for shorten_branches
|
/* The placement of the splitting that we do for shorten_branches
|
depends on whether regstack is used by the target or not. */
|
depends on whether regstack is used by the target or not. */
|
static bool
|
static bool
|
gate_do_final_split (void)
|
gate_do_final_split (void)
|
{
|
{
|
#if defined (HAVE_ATTR_length) && !defined (STACK_REGS)
|
#if defined (HAVE_ATTR_length) && !defined (STACK_REGS)
|
return 1;
|
return 1;
|
#else
|
#else
|
return 0;
|
return 0;
|
#endif
|
#endif
|
}
|
}
|
|
|
struct tree_opt_pass pass_split_for_shorten_branches =
|
struct tree_opt_pass pass_split_for_shorten_branches =
|
{
|
{
|
"split3", /* name */
|
"split3", /* name */
|
gate_do_final_split, /* gate */
|
gate_do_final_split, /* gate */
|
split_all_insns_noflow, /* execute */
|
split_all_insns_noflow, /* execute */
|
NULL, /* sub */
|
NULL, /* sub */
|
NULL, /* next */
|
NULL, /* next */
|
0, /* static_pass_number */
|
0, /* static_pass_number */
|
TV_SHORTEN_BRANCH, /* tv_id */
|
TV_SHORTEN_BRANCH, /* tv_id */
|
0, /* properties_required */
|
0, /* properties_required */
|
0, /* properties_provided */
|
0, /* properties_provided */
|
0, /* properties_destroyed */
|
0, /* properties_destroyed */
|
0, /* todo_flags_start */
|
0, /* todo_flags_start */
|
TODO_dump_func, /* todo_flags_finish */
|
TODO_dump_func, /* todo_flags_finish */
|
0 /* letter */
|
0 /* letter */
|
};
|
};
|
|
|
|
|
static bool
|
static bool
|
gate_handle_split_before_regstack (void)
|
gate_handle_split_before_regstack (void)
|
{
|
{
|
#if defined (HAVE_ATTR_length) && defined (STACK_REGS)
|
#if defined (HAVE_ATTR_length) && defined (STACK_REGS)
|
/* If flow2 creates new instructions which need splitting
|
/* If flow2 creates new instructions which need splitting
|
and scheduling after reload is not done, they might not be
|
and scheduling after reload is not done, they might not be
|
split until final which doesn't allow splitting
|
split until final which doesn't allow splitting
|
if HAVE_ATTR_length. */
|
if HAVE_ATTR_length. */
|
# ifdef INSN_SCHEDULING
|
# ifdef INSN_SCHEDULING
|
return (optimize && !flag_schedule_insns_after_reload);
|
return (optimize && !flag_schedule_insns_after_reload);
|
# else
|
# else
|
return (optimize);
|
return (optimize);
|
# endif
|
# endif
|
#else
|
#else
|
return 0;
|
return 0;
|
#endif
|
#endif
|
}
|
}
|
|
|
struct tree_opt_pass pass_split_before_regstack =
|
struct tree_opt_pass pass_split_before_regstack =
|
{
|
{
|
"split2", /* name */
|
"split2", /* name */
|
gate_handle_split_before_regstack, /* gate */
|
gate_handle_split_before_regstack, /* gate */
|
rest_of_handle_split_all_insns, /* execute */
|
rest_of_handle_split_all_insns, /* execute */
|
NULL, /* sub */
|
NULL, /* sub */
|
NULL, /* next */
|
NULL, /* next */
|
0, /* static_pass_number */
|
0, /* static_pass_number */
|
TV_SHORTEN_BRANCH, /* tv_id */
|
TV_SHORTEN_BRANCH, /* tv_id */
|
0, /* properties_required */
|
0, /* properties_required */
|
0, /* properties_provided */
|
0, /* properties_provided */
|
0, /* properties_destroyed */
|
0, /* properties_destroyed */
|
0, /* todo_flags_start */
|
0, /* todo_flags_start */
|
TODO_dump_func, /* todo_flags_finish */
|
TODO_dump_func, /* todo_flags_finish */
|
0 /* letter */
|
0 /* letter */
|
};
|
};
|
|
|
