blob: 5a42c45361d5c6d615f0ad58d9b08fc096e1eaee [file] [log] [blame]
/* Subroutines used by or related to instruction recognition.
Copyright (C) 1987-2021 Free Software Foundation, Inc.
This file is part of GCC.
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
Software Foundation; either version 3, or (at your option) any later
version.
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "backend.h"
#include "target.h"
#include "rtl.h"
#include "tree.h"
#include "cfghooks.h"
#include "df.h"
#include "memmodel.h"
#include "tm_p.h"
#include "insn-config.h"
#include "regs.h"
#include "emit-rtl.h"
#include "recog.h"
#include "insn-attr.h"
#include "addresses.h"
#include "cfgrtl.h"
#include "cfgbuild.h"
#include "cfgcleanup.h"
#include "reload.h"
#include "tree-pass.h"
#include "function-abi.h"
#ifndef STACK_POP_CODE
#if STACK_GROWS_DOWNWARD
#define STACK_POP_CODE POST_INC
#else
#define STACK_POP_CODE POST_DEC
#endif
#endif
static void validate_replace_rtx_1 (rtx *, rtx, rtx, rtx_insn *, bool);
static void validate_replace_src_1 (rtx *, void *);
static rtx_insn *split_insn (rtx_insn *);
struct target_recog default_target_recog;
#if SWITCHABLE_TARGET
struct target_recog *this_target_recog = &default_target_recog;
#endif
/* Nonzero means allow operands to be volatile.
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).
This should be 1 if all valid insns need to be recognized,
such as in reginfo.c and final.c and reload.c.
init_recog and init_recog_no_volatile are responsible for setting this. */
int volatile_ok;
struct recog_data_d recog_data;
/* Contains a vector of operand_alternative structures, such that
operand OP of alternative A is at index A * n_operands + OP.
Set up by preprocess_constraints. */
const operand_alternative *recog_op_alt;
/* Used to provide recog_op_alt for asms. */
static operand_alternative asm_op_alt[MAX_RECOG_OPERANDS
* MAX_RECOG_ALTERNATIVES];
/* On return from `constrain_operands', indicate which alternative
was satisfied. */
int which_alternative;
/* Nonzero after end of reload pass.
Set to 1 or 0 by toplev.c.
Controls the significance of (SUBREG (MEM)). */
int reload_completed;
/* Nonzero after thread_prologue_and_epilogue_insns has run. */
int epilogue_completed;
/* Initialize data used by the function `recog'.
This must be called once in the compilation of a function
before any insn recognition may be done in the function. */
void
init_recog_no_volatile (void)
{
volatile_ok = 0;
}
void
init_recog (void)
{
volatile_ok = 1;
}
/* Return true if labels in asm operands BODY are LABEL_REFs. */
static bool
asm_labels_ok (rtx body)
{
rtx asmop;
int i;
asmop = extract_asm_operands (body);
if (asmop == NULL_RTX)
return true;
for (i = 0; i < ASM_OPERANDS_LABEL_LENGTH (asmop); i++)
if (GET_CODE (ASM_OPERANDS_LABEL (asmop, i)) != LABEL_REF)
return false;
return true;
}
/* Check that X is an insn-body for an `asm' with operands
and that the operands mentioned in it are legitimate. */
int
check_asm_operands (rtx x)
{
int noperands;
rtx *operands;
const char **constraints;
int i;
if (!asm_labels_ok (x))
return 0;
/* Post-reload, be more strict with things. */
if (reload_completed)
{
/* ??? Doh! We've not got the wrapping insn. Cook one up. */
rtx_insn *insn = make_insn_raw (x);
extract_insn (insn);
constrain_operands (1, get_enabled_alternatives (insn));
return which_alternative >= 0;
}
noperands = asm_noperands (x);
if (noperands < 0)
return 0;
if (noperands == 0)
return 1;
operands = XALLOCAVEC (rtx, noperands);
constraints = XALLOCAVEC (const char *, noperands);
decode_asm_operands (x, operands, NULL, constraints, NULL, NULL);
for (i = 0; i < noperands; i++)
{
const char *c = constraints[i];
if (c[0] == '%')
c++;
if (! asm_operand_ok (operands[i], c, constraints))
return 0;
}
return 1;
}
/* Static data for the next two routines. */
struct change_t
{
rtx object;
int old_code;
int old_len;
bool unshare;
rtx *loc;
rtx old;
};
static change_t *changes;
static int changes_allocated;
static int num_changes = 0;
static int temporarily_undone_changes = 0;
/* Validate a proposed change to OBJECT. LOC is the location in the rtl
at which NEW_RTX will be placed. If NEW_LEN is >= 0, XVECLEN (NEW_RTX, 0)
will also be changed to NEW_LEN, which is no greater than the current
XVECLEN. If OBJECT is zero, no validation is done, the change is
simply made.
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
an INSN, CALL_INSN, or JUMP_INSN, the insn will be re-recognized with
the change in place.
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
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
or validate the memory reference with the change applied. If the result
is not valid for the machine, suppress the change and return zero.
Otherwise, perform the change and return 1. */
static bool
validate_change_1 (rtx object, rtx *loc, rtx new_rtx, bool in_group,
bool unshare, int new_len = -1)
{
gcc_assert (temporarily_undone_changes == 0);
rtx old = *loc;
/* Single-element parallels aren't valid and won't match anything.
Replace them with the single element. */
if (new_len == 1 && GET_CODE (new_rtx) == PARALLEL)
{
new_rtx = XVECEXP (new_rtx, 0, 0);
new_len = -1;
}
if ((old == new_rtx || rtx_equal_p (old, new_rtx))
&& (new_len < 0 || XVECLEN (new_rtx, 0) == new_len))
return 1;
gcc_assert ((in_group != 0 || num_changes == 0)
&& (new_len < 0 || new_rtx == *loc));
*loc = new_rtx;
/* Save the information describing this change. */
if (num_changes >= changes_allocated)
{
if (changes_allocated == 0)
/* This value allows for repeated substitutions inside complex
indexed addresses, or changes in up to 5 insns. */
changes_allocated = MAX_RECOG_OPERANDS * 5;
else
changes_allocated *= 2;
changes = XRESIZEVEC (change_t, changes, changes_allocated);
}
changes[num_changes].object = object;
changes[num_changes].loc = loc;
changes[num_changes].old = old;
changes[num_changes].old_len = (new_len >= 0 ? XVECLEN (new_rtx, 0) : -1);
changes[num_changes].unshare = unshare;
if (new_len >= 0)
XVECLEN (new_rtx, 0) = new_len;
if (object && !MEM_P (object))
{
/* Set INSN_CODE to force rerecognition of insn. Save old code in
case invalid. */
changes[num_changes].old_code = INSN_CODE (object);
INSN_CODE (object) = -1;
}
num_changes++;
/* If we are making a group of changes, return 1. Otherwise, validate the
change group we made. */
if (in_group)
return 1;
else
return apply_change_group ();
}
/* Wrapper for validate_change_1 without the UNSHARE argument defaulting
UNSHARE to false. */
bool
validate_change (rtx object, rtx *loc, rtx new_rtx, bool in_group)
{
return validate_change_1 (object, loc, new_rtx, in_group, false);
}
/* Wrapper for validate_change_1 without the UNSHARE argument defaulting
UNSHARE to true. */
bool
validate_unshare_change (rtx object, rtx *loc, rtx new_rtx, bool in_group)
{
return validate_change_1 (object, loc, new_rtx, in_group, true);
}
/* Change XVECLEN (*LOC, 0) to NEW_LEN. OBJECT, IN_GROUP and the return
value are as for validate_change_1. */
bool
validate_change_xveclen (rtx object, rtx *loc, int new_len, bool in_group)
{
return validate_change_1 (object, loc, *loc, in_group, false, new_len);
}
/* Keep X canonicalized if some changes have made it non-canonical; only
modifies the operands of X, not (for example) its code. Simplifications
are not the job of this routine.
Return true if anything was changed. */
bool
canonicalize_change_group (rtx_insn *insn, rtx x)
{
if (COMMUTATIVE_P (x)
&& swap_commutative_operands_p (XEXP (x, 0), XEXP (x, 1)))
{
/* Oops, the caller has made X no longer canonical.
Let's redo the changes in the correct order. */
rtx tem = XEXP (x, 0);
validate_unshare_change (insn, &XEXP (x, 0), XEXP (x, 1), 1);
validate_unshare_change (insn, &XEXP (x, 1), tem, 1);
return true;
}
else
return false;
}
/* This subroutine of apply_change_group verifies whether the changes to INSN
were valid; i.e. whether INSN can still be recognized.
If IN_GROUP is true clobbers which have to be added in order to
match the instructions will be added to the current change group.
Otherwise the changes will take effect immediately. */
int
insn_invalid_p (rtx_insn *insn, bool in_group)
{
rtx pat = PATTERN (insn);
int num_clobbers = 0;
/* If we are before reload and the pattern is a SET, see if we can add
clobbers. */
int icode = recog (pat, insn,
(GET_CODE (pat) == SET
&& ! reload_completed
&& ! reload_in_progress)
? &num_clobbers : 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
this is not an asm and the insn wasn't recognized. */
if ((is_asm && ! check_asm_operands (PATTERN (insn)))
|| (!is_asm && icode < 0))
return 1;
/* 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.
Otherwise, add them. */
if (num_clobbers > 0)
{
rtx newpat;
if (added_clobbers_hard_reg_p (icode))
return 1;
newpat = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (num_clobbers + 1));
XVECEXP (newpat, 0, 0) = pat;
add_clobbers (newpat, icode);
if (in_group)
validate_change (insn, &PATTERN (insn), newpat, 1);
else
PATTERN (insn) = pat = newpat;
}
/* After reload, verify that all constraints are satisfied. */
if (reload_completed)
{
extract_insn (insn);
if (! constrain_operands (1, get_preferred_alternatives (insn)))
return 1;
}
INSN_CODE (insn) = icode;
return 0;
}
/* Return number of changes made and not validated yet. */
int
num_changes_pending (void)
{
return num_changes;
}
/* Tentatively apply the changes numbered NUM and up.
Return 1 if all changes are valid, zero otherwise. */
int
verify_changes (int num)
{
int i;
rtx last_validated = NULL_RTX;
/* The changes have been applied and all INSN_CODEs have been reset to force
rerecognition.
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
and it is recognized. In the latter case, if reload has completed,
we also require that the operands meet the constraints for
the insn. */
for (i = num; i < num_changes; i++)
{
rtx object = changes[i].object;
/* If there is no object to test or if it is the same as the one we
already tested, ignore it. */
if (object == 0 || object == last_validated)
continue;
if (MEM_P (object))
{
if (! memory_address_addr_space_p (GET_MODE (object),
XEXP (object, 0),
MEM_ADDR_SPACE (object)))
break;
}
else if (/* changes[i].old might be zero, e.g. when putting a
REG_FRAME_RELATED_EXPR into a previously empty list. */
changes[i].old
&& REG_P (changes[i].old)
&& asm_noperands (PATTERN (object)) > 0
&& register_asm_p (changes[i].old))
{
/* Don't allow changes of hard register operands to inline
assemblies if they have been defined as register asm ("x"). */
break;
}
else if (DEBUG_INSN_P (object))
continue;
else if (insn_invalid_p (as_a <rtx_insn *> (object), true))
{
rtx pat = PATTERN (object);
/* Perhaps we couldn't recognize the insn because there were
extra CLOBBERs at the end. If so, try to re-recognize
without the last CLOBBER (later iterations will cause each of
them to be eliminated, in turn). But don't do this if we
have an ASM_OPERAND. */
if (GET_CODE (pat) == PARALLEL
&& GET_CODE (XVECEXP (pat, 0, XVECLEN (pat, 0) - 1)) == CLOBBER
&& asm_noperands (PATTERN (object)) < 0)
{
rtx newpat;
if (XVECLEN (pat, 0) == 2)
newpat = XVECEXP (pat, 0, 0);
else
{
int j;
newpat
= gen_rtx_PARALLEL (VOIDmode,
rtvec_alloc (XVECLEN (pat, 0) - 1));
for (j = 0; j < XVECLEN (newpat, 0); j++)
XVECEXP (newpat, 0, j) = XVECEXP (pat, 0, j);
}
/* Add a new change to this group to replace the pattern
with this new pattern. Then consider this change
as having succeeded. The change we added will
cause the entire call to fail if things remain invalid.
Note that this can lose if a later change than the one
we are processing specified &XVECEXP (PATTERN (object), 0, X)
but this shouldn't occur. */
validate_change (object, &PATTERN (object), newpat, 1);
continue;
}
else if (GET_CODE (pat) == USE || GET_CODE (pat) == CLOBBER
|| GET_CODE (pat) == VAR_LOCATION)
/* If this insn is a CLOBBER or USE, it is always valid, but is
never recognized. */
continue;
else
break;
}
last_validated = object;
}
return (i == num_changes);
}
/* A group of changes has previously been issued with validate_change
and verified with verify_changes. Call df_insn_rescan for each of
the insn changed and clear num_changes. */
void
confirm_change_group (void)
{
int i;
rtx last_object = NULL;
gcc_assert (temporarily_undone_changes == 0);
for (i = 0; i < num_changes; i++)
{
rtx object = changes[i].object;
if (changes[i].unshare)
*changes[i].loc = copy_rtx (*changes[i].loc);
/* Avoid unnecessary rescanning when multiple changes to same instruction
are made. */
if (object)
{
if (object != last_object && last_object && INSN_P (last_object))
df_insn_rescan (as_a <rtx_insn *> (last_object));
last_object = object;
}
}
if (last_object && INSN_P (last_object))
df_insn_rescan (as_a <rtx_insn *> (last_object));
num_changes = 0;
}
/* Apply a group of changes previously issued with `validate_change'.
If all changes are valid, call confirm_change_group and return 1,
otherwise, call cancel_changes and return 0. */
int
apply_change_group (void)
{
if (verify_changes (0))
{
confirm_change_group ();
return 1;
}
else
{
cancel_changes (0);
return 0;
}
}
/* Return the number of changes so far in the current group. */
int
num_validated_changes (void)
{
return num_changes;
}
/* Retract the changes numbered NUM and up. */
void
cancel_changes (int num)
{
gcc_assert (temporarily_undone_changes == 0);
int i;
/* Back out all the changes. Do this in the opposite order in which
they were made. */
for (i = num_changes - 1; i >= num; i--)
{
if (changes[i].old_len >= 0)
XVECLEN (*changes[i].loc, 0) = changes[i].old_len;
else
*changes[i].loc = changes[i].old;
if (changes[i].object && !MEM_P (changes[i].object))
INSN_CODE (changes[i].object) = changes[i].old_code;
}
num_changes = num;
}
/* Swap the status of change NUM from being applied to not being applied,
or vice versa. */
static void
swap_change (int num)
{
if (changes[num].old_len >= 0)
std::swap (XVECLEN (*changes[num].loc, 0), changes[num].old_len);
else
std::swap (*changes[num].loc, changes[num].old);
if (changes[num].object && !MEM_P (changes[num].object))
std::swap (INSN_CODE (changes[num].object), changes[num].old_code);
}
/* Temporarily undo all the changes numbered NUM and up, with a view
to reapplying them later. The next call to the changes machinery
must be:
redo_changes (NUM)
otherwise things will end up in an invalid state. */
void
temporarily_undo_changes (int num)
{
gcc_assert (temporarily_undone_changes == 0 && num <= num_changes);
for (int i = num_changes - 1; i >= num; i--)
swap_change (i);
temporarily_undone_changes = num_changes - num;
}
/* Redo the changes that were temporarily undone by:
temporarily_undo_changes (NUM). */
void
redo_changes (int num)
{
gcc_assert (temporarily_undone_changes == num_changes - num);
for (int i = num; i < num_changes; ++i)
swap_change (i);
temporarily_undone_changes = 0;
}
/* Reduce conditional compilation elsewhere. */
/* A subroutine of validate_replace_rtx_1 that tries to simplify the resulting
rtx. */
static void
simplify_while_replacing (rtx *loc, rtx to, rtx_insn *object,
machine_mode op0_mode)
{
rtx x = *loc;
enum rtx_code code = GET_CODE (x);
rtx new_rtx = NULL_RTX;
scalar_int_mode is_mode;
if (SWAPPABLE_OPERANDS_P (x)
&& swap_commutative_operands_p (XEXP (x, 0), XEXP (x, 1)))
{
validate_unshare_change (object, loc,
gen_rtx_fmt_ee (COMMUTATIVE_ARITH_P (x) ? code
: swap_condition (code),
GET_MODE (x), XEXP (x, 1),
XEXP (x, 0)), 1);
x = *loc;
code = GET_CODE (x);
}
/* Canonicalize arithmetics with all constant operands. */
switch (GET_RTX_CLASS (code))
{
case RTX_UNARY:
if (CONSTANT_P (XEXP (x, 0)))
new_rtx = simplify_unary_operation (code, GET_MODE (x), XEXP (x, 0),
op0_mode);
break;
case RTX_COMM_ARITH:
case RTX_BIN_ARITH:
if (CONSTANT_P (XEXP (x, 0)) && CONSTANT_P (XEXP (x, 1)))
new_rtx = simplify_binary_operation (code, GET_MODE (x), XEXP (x, 0),
XEXP (x, 1));
break;
case RTX_COMPARE:
case RTX_COMM_COMPARE:
if (CONSTANT_P (XEXP (x, 0)) && CONSTANT_P (XEXP (x, 1)))
new_rtx = simplify_relational_operation (code, GET_MODE (x), op0_mode,
XEXP (x, 0), XEXP (x, 1));
break;
default:
break;
}
if (new_rtx)
{
validate_change (object, loc, new_rtx, 1);
return;
}
switch (code)
{
case PLUS:
/* If we have a PLUS whose second operand is now a CONST_INT, use
simplify_gen_binary to try to simplify it.
??? We may want later to remove this, once simplification is
separated from this function. */
if (CONST_INT_P (XEXP (x, 1)) && XEXP (x, 1) == to)
validate_change (object, loc,
simplify_gen_binary
(PLUS, GET_MODE (x), XEXP (x, 0), XEXP (x, 1)), 1);
break;
case MINUS:
if (CONST_SCALAR_INT_P (XEXP (x, 1)))
validate_change (object, loc,
simplify_gen_binary
(PLUS, GET_MODE (x), XEXP (x, 0),
simplify_gen_unary (NEG,
GET_MODE (x), XEXP (x, 1),
GET_MODE (x))), 1);
break;
case ZERO_EXTEND:
case SIGN_EXTEND:
if (GET_MODE (XEXP (x, 0)) == VOIDmode)
{
new_rtx = simplify_gen_unary (code, GET_MODE (x), XEXP (x, 0),
op0_mode);
/* If any of the above failed, substitute in something that
we know won't be recognized. */
if (!new_rtx)
new_rtx = gen_rtx_CLOBBER (GET_MODE (x), const0_rtx);
validate_change (object, loc, new_rtx, 1);
}
break;
case SUBREG:
/* All subregs possible to simplify should be simplified. */
new_rtx = simplify_subreg (GET_MODE (x), SUBREG_REG (x), op0_mode,
SUBREG_BYTE (x));
/* Subregs of VOIDmode operands are incorrect. */
if (!new_rtx && GET_MODE (SUBREG_REG (x)) == VOIDmode)
new_rtx = gen_rtx_CLOBBER (GET_MODE (x), const0_rtx);
if (new_rtx)
validate_change (object, loc, new_rtx, 1);
break;
case ZERO_EXTRACT:
case SIGN_EXTRACT:
/* 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
likely to be an insertion operation; if it was, nothing bad will
happen, we might just fail in some cases). */
if (MEM_P (XEXP (x, 0))
&& is_a <scalar_int_mode> (GET_MODE (XEXP (x, 0)), &is_mode)
&& CONST_INT_P (XEXP (x, 1))
&& CONST_INT_P (XEXP (x, 2))
&& !mode_dependent_address_p (XEXP (XEXP (x, 0), 0),
MEM_ADDR_SPACE (XEXP (x, 0)))
&& !MEM_VOLATILE_P (XEXP (x, 0)))
{
int pos = INTVAL (XEXP (x, 2));
machine_mode new_mode = is_mode;
if (GET_CODE (x) == ZERO_EXTRACT && targetm.have_extzv ())
new_mode = insn_data[targetm.code_for_extzv].operand[1].mode;
else if (GET_CODE (x) == SIGN_EXTRACT && targetm.have_extv ())
new_mode = insn_data[targetm.code_for_extv].operand[1].mode;
scalar_int_mode wanted_mode = (new_mode == VOIDmode
? word_mode
: as_a <scalar_int_mode> (new_mode));
/* If we have a narrower mode, we can do something. */
if (GET_MODE_SIZE (wanted_mode) < GET_MODE_SIZE (is_mode))
{
int offset = pos / BITS_PER_UNIT;
rtx newmem;
/* If the bytes and bits are counted differently, we
must adjust the offset. */
if (BYTES_BIG_ENDIAN != BITS_BIG_ENDIAN)
offset =
(GET_MODE_SIZE (is_mode) - GET_MODE_SIZE (wanted_mode) -
offset);
gcc_assert (GET_MODE_PRECISION (wanted_mode)
== GET_MODE_BITSIZE (wanted_mode));
pos %= GET_MODE_BITSIZE (wanted_mode);
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, 0), newmem, 1);
}
}
break;
default:
break;
}
}
/* Replace every occurrence of FROM in X with TO. Mark each change with
validate_change passing OBJECT. */
static void
validate_replace_rtx_1 (rtx *loc, rtx from, rtx to, rtx_insn *object,
bool simplify)
{
int i, j;
const char *fmt;
rtx x = *loc;
enum rtx_code code;
machine_mode op0_mode = VOIDmode;
int prev_changes = num_changes;
if (!x)
return;
code = GET_CODE (x);
fmt = GET_RTX_FORMAT (code);
if (fmt[0] == 'e')
op0_mode = GET_MODE (XEXP (x, 0));
/* 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
operands look similar. */
if (x == from
|| (REG_P (x) && REG_P (from)
&& GET_MODE (x) == GET_MODE (from)
&& REGNO (x) == REGNO (from))
|| (GET_CODE (x) == GET_CODE (from) && GET_MODE (x) == GET_MODE (from)
&& rtx_equal_p (x, from)))
{
validate_unshare_change (object, loc, to, 1);
return;
}
/* Call ourself recursively to perform the replacements.
We must not replace inside already replaced expression, otherwise we
get infinite recursion for replacements like (reg X)->(subreg (reg X))
so we must special case shared ASM_OPERANDS. */
if (GET_CODE (x) == PARALLEL)
{
for (j = XVECLEN (x, 0) - 1; j >= 0; j--)
{
if (j && GET_CODE (XVECEXP (x, 0, j)) == SET
&& GET_CODE (SET_SRC (XVECEXP (x, 0, j))) == ASM_OPERANDS)
{
/* Verify that operands are really shared. */
gcc_assert (ASM_OPERANDS_INPUT_VEC (SET_SRC (XVECEXP (x, 0, 0)))
== ASM_OPERANDS_INPUT_VEC (SET_SRC (XVECEXP
(x, 0, j))));
validate_replace_rtx_1 (&SET_DEST (XVECEXP (x, 0, j)),
from, to, object, simplify);
}
else
validate_replace_rtx_1 (&XVECEXP (x, 0, j), from, to, object,
simplify);
}
}
else
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
{
if (fmt[i] == 'e')
validate_replace_rtx_1 (&XEXP (x, i), from, to, object, simplify);
else if (fmt[i] == 'E')
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
validate_replace_rtx_1 (&XVECEXP (x, i, j), from, to, object,
simplify);
}
/* If we didn't substitute, there is nothing more to do. */
if (num_changes == prev_changes)
return;
/* ??? The regmove is no more, so is this aberration still necessary? */
/* Allow substituted expression to have different mode. This is used by
regmove to change mode of pseudo register. */
if (fmt[0] == 'e' && GET_MODE (XEXP (x, 0)) != VOIDmode)
op0_mode = GET_MODE (XEXP (x, 0));
/* Do changes needed to keep rtx consistent. Don't do any other
simplifications, as it is not our job. */
if (simplify)
simplify_while_replacing (loc, to, object, op0_mode);
}
/* Try replacing every occurrence of FROM in subexpression LOC of INSN
with TO. After all changes have been made, validate by seeing
if INSN is still valid. */
int
validate_replace_rtx_subexp (rtx from, rtx to, rtx_insn *insn, rtx *loc)
{
validate_replace_rtx_1 (loc, from, to, insn, true);
return apply_change_group ();
}
/* Try replacing every occurrence of FROM in INSN with TO. After all
changes have been made, validate by seeing if INSN is still valid. */
int
validate_replace_rtx (rtx from, rtx to, rtx_insn *insn)
{
validate_replace_rtx_1 (&PATTERN (insn), from, to, insn, true);
return apply_change_group ();
}
/* Try replacing every occurrence of FROM in WHERE with TO. Assume that WHERE
is a part of INSN. After all changes have been made, validate by seeing if
INSN is still valid.
validate_replace_rtx (from, to, insn) is equivalent to
validate_replace_rtx_part (from, to, &PATTERN (insn), insn). */
int
validate_replace_rtx_part (rtx from, rtx to, rtx *where, rtx_insn *insn)
{
validate_replace_rtx_1 (where, from, to, insn, true);
return apply_change_group ();
}
/* Same as above, but do not simplify rtx afterwards. */
int
validate_replace_rtx_part_nosimplify (rtx from, rtx to, rtx *where,
rtx_insn *insn)
{
validate_replace_rtx_1 (where, from, to, insn, false);
return apply_change_group ();
}
/* Try replacing every occurrence of FROM in INSN with TO. This also
will replace in REG_EQUAL and REG_EQUIV notes. */
void
validate_replace_rtx_group (rtx from, rtx to, rtx_insn *insn)
{
rtx note;
validate_replace_rtx_1 (&PATTERN (insn), from, to, insn, true);
for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
if (REG_NOTE_KIND (note) == REG_EQUAL
|| REG_NOTE_KIND (note) == REG_EQUIV)
validate_replace_rtx_1 (&XEXP (note, 0), from, to, insn, true);
}
/* Function called by note_uses to replace used subexpressions. */
struct validate_replace_src_data
{
rtx from; /* Old RTX */
rtx to; /* New RTX */
rtx_insn *insn; /* Insn in which substitution is occurring. */
};
static void
validate_replace_src_1 (rtx *x, void *data)
{
struct validate_replace_src_data *d
= (struct validate_replace_src_data *) data;
validate_replace_rtx_1 (x, d->from, d->to, d->insn, true);
}
/* Try replacing every occurrence of FROM in INSN with TO, avoiding
SET_DESTs. */
void
validate_replace_src_group (rtx from, rtx to, rtx_insn *insn)
{
struct validate_replace_src_data d;
d.from = from;
d.to = to;
d.insn = insn;
note_uses (&PATTERN (insn), validate_replace_src_1, &d);
}
/* Try simplify INSN.
Invoke simplify_rtx () on every SET_SRC and SET_DEST inside the INSN's
pattern and return true if something was simplified. */
bool
validate_simplify_insn (rtx_insn *insn)
{
int i;
rtx pat = NULL;
rtx newpat = NULL;
pat = PATTERN (insn);
if (GET_CODE (pat) == SET)
{
newpat = simplify_rtx (SET_SRC (pat));
if (newpat && !rtx_equal_p (SET_SRC (pat), newpat))
validate_change (insn, &SET_SRC (pat), newpat, 1);
newpat = simplify_rtx (SET_DEST (pat));
if (newpat && !rtx_equal_p (SET_DEST (pat), newpat))
validate_change (insn, &SET_DEST (pat), newpat, 1);
}
else if (GET_CODE (pat) == PARALLEL)
for (i = 0; i < XVECLEN (pat, 0); i++)
{
rtx s = XVECEXP (pat, 0, i);
if (GET_CODE (XVECEXP (pat, 0, i)) == SET)
{
newpat = simplify_rtx (SET_SRC (s));
if (newpat && !rtx_equal_p (SET_SRC (s), newpat))
validate_change (insn, &SET_SRC (s), newpat, 1);
newpat = simplify_rtx (SET_DEST (s));
if (newpat && !rtx_equal_p (SET_DEST (s), newpat))
validate_change (insn, &SET_DEST (s), newpat, 1);
}
}
return ((num_changes_pending () > 0) && (apply_change_group () > 0));
}
/* Try to process the address of memory expression MEM. Return true on
success; leave the caller to clean up on failure. */
bool
insn_propagation::apply_to_mem_1 (rtx mem)
{
auto old_num_changes = num_validated_changes ();
mem_depth += 1;
bool res = apply_to_rvalue_1 (&XEXP (mem, 0));
mem_depth -= 1;
if (!res)
return false;
if (old_num_changes != num_validated_changes ()
&& should_check_mems
&& !check_mem (old_num_changes, mem))
return false;
return true;
}
/* Try to process the rvalue expression at *LOC. Return true on success;
leave the caller to clean up on failure. */
bool
insn_propagation::apply_to_rvalue_1 (rtx *loc)
{
rtx x = *loc;
enum rtx_code code = GET_CODE (x);
machine_mode mode = GET_MODE (x);
auto old_num_changes = num_validated_changes ();
if (from && GET_CODE (x) == GET_CODE (from) && rtx_equal_p (x, from))
{
/* Don't replace register asms in asm statements; we mustn't
change the user's register allocation. */
if (REG_P (x)
&& HARD_REGISTER_P (x)
&& register_asm_p (x)
&& asm_noperands (PATTERN (insn)) > 0)
return false;
if (should_unshare)
validate_unshare_change (insn, loc, to, 1);
else
validate_change (insn, loc, to, 1);
if (mem_depth && !REG_P (to) && !CONSTANT_P (to))
{
/* We're substituting into an address, but TO will have the
form expected outside an address. Canonicalize it if
necessary. */
insn_propagation subprop (insn);
subprop.mem_depth += 1;
if (!subprop.apply_to_rvalue (loc))
gcc_unreachable ();
if (should_unshare
&& num_validated_changes () != old_num_changes + 1)
{
/* TO is owned by someone else, so create a copy and
return TO to its original form. */
rtx to = copy_rtx (*loc);
cancel_changes (old_num_changes);
validate_change (insn, loc, to, 1);
}
}
num_replacements += 1;
should_unshare = true;
result_flags |= UNSIMPLIFIED;
return true;
}
/* Recursively apply the substitution and see if we can simplify
the result. This specifically shouldn't use simplify_gen_* for
speculative simplifications, since we want to avoid generating new
expressions where possible. */
auto old_result_flags = result_flags;
rtx newx = NULL_RTX;
bool recurse_p = false;
switch (GET_RTX_CLASS (code))
{
case RTX_UNARY:
{
machine_mode op0_mode = GET_MODE (XEXP (x, 0));
if (!apply_to_rvalue_1 (&XEXP (x, 0)))
return false;
if (from && old_num_changes == num_validated_changes ())
return true;
newx = simplify_unary_operation (code, mode, XEXP (x, 0), op0_mode);
break;
}
case RTX_BIN_ARITH:
case RTX_COMM_ARITH:
{
if (!apply_to_rvalue_1 (&XEXP (x, 0))
|| !apply_to_rvalue_1 (&XEXP (x, 1)))
return false;
if (from && old_num_changes == num_validated_changes ())
return true;
if (GET_RTX_CLASS (code) == RTX_COMM_ARITH
&& swap_commutative_operands_p (XEXP (x, 0), XEXP (x, 1)))
newx = simplify_gen_binary (code, mode, XEXP (x, 1), XEXP (x, 0));
else
newx = simplify_binary_operation (code, mode,
XEXP (x, 0), XEXP (x, 1));
break;
}
case RTX_COMPARE:
case RTX_COMM_COMPARE:
{
machine_mode op_mode = (GET_MODE (XEXP (x, 0)) != VOIDmode
? GET_MODE (XEXP (x, 0))
: GET_MODE (XEXP (x, 1)));
if (!apply_to_rvalue_1 (&XEXP (x, 0))
|| !apply_to_rvalue_1 (&XEXP (x, 1)))
return false;
if (from && old_num_changes == num_validated_changes ())
return true;
newx = simplify_relational_operation (code, mode, op_mode,
XEXP (x, 0), XEXP (x, 1));
break;
}
case RTX_TERNARY:
case RTX_BITFIELD_OPS:
{
machine_mode op0_mode = GET_MODE (XEXP (x, 0));
if (!apply_to_rvalue_1 (&XEXP (x, 0))
|| !apply_to_rvalue_1 (&XEXP (x, 1))
|| !apply_to_rvalue_1 (&XEXP (x, 2)))
return false;
if (from && old_num_changes == num_validated_changes ())
return true;
newx = simplify_ternary_operation (code, mode, op0_mode,
XEXP (x, 0), XEXP (x, 1),
XEXP (x, 2));
break;
}
case RTX_EXTRA:
if (code == SUBREG)
{
machine_mode inner_mode = GET_MODE (SUBREG_REG (x));
if (!apply_to_rvalue_1 (&SUBREG_REG (x)))
return false;
if (from && old_num_changes == num_validated_changes ())
return true;
rtx inner = SUBREG_REG (x);
newx = simplify_subreg (mode, inner, inner_mode, SUBREG_BYTE (x));
/* Reject the same cases that simplify_gen_subreg would. */
if (!newx
&& (GET_CODE (inner) == SUBREG
|| GET_CODE (inner) == CONCAT
|| GET_MODE (inner) == VOIDmode
|| !validate_subreg (mode, inner_mode,
inner, SUBREG_BYTE (x))))
{
failure_reason = "would create an invalid subreg";
return false;
}
break;
}
else
recurse_p = true;
break;
case RTX_OBJ:
if (code == LO_SUM)
{
if (!apply_to_rvalue_1 (&XEXP (x, 0))
|| !apply_to_rvalue_1 (&XEXP (x, 1)))
return false;
if (from && old_num_changes == num_validated_changes ())
return true;
/* (lo_sum (high x) y) -> y where x and y have the same base. */
rtx op0 = XEXP (x, 0);
rtx op1 = XEXP (x, 1);
if (GET_CODE (op0) == HIGH)
{
rtx base0, base1, offset0, offset1;
split_const (XEXP (op0, 0), &base0, &offset0);
split_const (op1, &base1, &offset1);
if (rtx_equal_p (base0, base1))
newx = op1;
}
}
else if (code == REG)
{
if (from && REG_P (from) && reg_overlap_mentioned_p (x, from))
{
failure_reason = "inexact register overlap";
return false;
}
}
else if (code == MEM)
return apply_to_mem_1 (x);
else
recurse_p = true;
break;
case RTX_CONST_OBJ:
break;
case RTX_AUTOINC:
if (from && reg_overlap_mentioned_p (XEXP (x, 0), from))
{
failure_reason = "is subject to autoinc";
return false;
}
recurse_p = true;
break;
case RTX_MATCH:
case RTX_INSN:
gcc_unreachable ();
}
if (recurse_p)
{
const char *fmt = GET_RTX_FORMAT (code);
for (int i = 0; fmt[i]; i++)
switch (fmt[i])
{
case 'E':
for (int j = 0; j < XVECLEN (x, i); j++)
if (!apply_to_rvalue_1 (&XVECEXP (x, i, j)))
return false;
break;
case 'e':
if (XEXP (x, i) && !apply_to_rvalue_1 (&XEXP (x, i)))
return false;
break;
}
}
else if (newx && !rtx_equal_p (x, newx))
{
/* All substitutions made by OLD_NUM_CHANGES onwards have been
simplified. */
result_flags = ((result_flags & ~UNSIMPLIFIED)
| (old_result_flags & UNSIMPLIFIED));
if (should_note_simplifications)
note_simplification (old_num_changes, old_result_flags, x, newx);
/* There's no longer any point unsharing the substitutions made
for subexpressions, since we'll just copy this one instead. */
bool unshare = false;
for (int i = old_num_changes; i < num_changes; ++i)
{
unshare |= changes[i].unshare;
changes[i].unshare = false;
}
if (unshare)
validate_unshare_change (insn, loc, newx, 1);
else
validate_change (insn, loc, newx, 1);
}
return true;
}
/* Try to process the lvalue expression at *LOC. Return true on success;
leave the caller to clean up on failure. */
bool
insn_propagation::apply_to_lvalue_1 (rtx dest)
{
rtx old_dest = dest;
while (GET_CODE (dest) == SUBREG
|| GET_CODE (dest) == ZERO_EXTRACT
|| GET_CODE (dest) == STRICT_LOW_PART)
{
if (GET_CODE (dest) == ZERO_EXTRACT
&& (!apply_to_rvalue_1 (&XEXP (dest, 1))
|| !apply_to_rvalue_1 (&XEXP (dest, 2))))
return false;
dest = XEXP (dest, 0);
}
if (MEM_P (dest))
return apply_to_mem_1 (dest);
/* Check whether the substitution is safe in the presence of this lvalue. */
if (!from
|| dest == old_dest
|| !REG_P (dest)
|| !reg_overlap_mentioned_p (dest, from))
return true;
if (SUBREG_P (old_dest)
&& SUBREG_REG (old_dest) == dest
&& !read_modify_subreg_p (old_dest))
return true;
failure_reason = "is part of a read-write destination";
return false;
}
/* Try to process the instruction pattern at *LOC. Return true on success;
leave the caller to clean up on failure. */
bool
insn_propagation::apply_to_pattern_1 (rtx *loc)
{
rtx body = *loc;
switch (GET_CODE (body))
{
case COND_EXEC:
return (apply_to_rvalue_1 (&COND_EXEC_TEST (body))
&& apply_to_pattern_1 (&COND_EXEC_CODE (body)));
case PARALLEL:
{
int last = XVECLEN (body, 0) - 1;
for (int i = 0; i < last; ++i)
if (!apply_to_pattern_1 (&XVECEXP (body, 0, i)))
return false;
return apply_to_pattern_1 (&XVECEXP (body, 0, last));
}
case ASM_OPERANDS:
for (int i = 0, len = ASM_OPERANDS_INPUT_LENGTH (body); i < len; ++i)
if (!apply_to_rvalue_1 (&ASM_OPERANDS_INPUT (body, i)))
return false;
return true;
case CLOBBER:
return apply_to_lvalue_1 (XEXP (body, 0));
case SET:
return (apply_to_lvalue_1 (SET_DEST (body))
&& apply_to_rvalue_1 (&SET_SRC (body)));
default:
/* All the other possibilities never store and can use a normal
rtx walk. This includes:
- USE
- TRAP_IF
- PREFETCH
- UNSPEC
- UNSPEC_VOLATILE. */
return apply_to_rvalue_1 (loc);
}
}
/* Apply this insn_propagation object's simplification or substitution
to the instruction pattern at LOC. */
bool
insn_propagation::apply_to_pattern (rtx *loc)
{
unsigned int num_changes = num_validated_changes ();
bool res = apply_to_pattern_1 (loc);
if (!res)
cancel_changes (num_changes);
return res;
}
/* Apply this insn_propagation object's simplification or substitution
to the rvalue expression at LOC. */
bool
insn_propagation::apply_to_rvalue (rtx *loc)
{
unsigned int num_changes = num_validated_changes ();
bool res = apply_to_rvalue_1 (loc);
if (!res)
cancel_changes (num_changes);
return res;
}
/* Check whether INSN matches a specific alternative of an .md pattern. */
bool
valid_insn_p (rtx_insn *insn)
{
recog_memoized (insn);
if (INSN_CODE (insn) < 0)
return false;
extract_insn (insn);
/* We don't know whether the insn will be in code that is optimized
for size or speed, so consider all enabled alternatives. */
if (!constrain_operands (1, get_enabled_alternatives (insn)))
return false;
return true;
}
/* Return true if OP is a valid general operand for machine mode MODE.
This is either a register reference, a memory reference,
or a constant. In the case of a memory reference, the address
is checked for general validity for the target machine.
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.
If MODE is VOIDmode, OP is checked for validity for whatever mode
it has.
The main use of this function is as a predicate in match_operand
expressions in the machine description. */
bool
general_operand (rtx op, machine_mode mode)
{
enum rtx_code code = GET_CODE (op);
if (mode == VOIDmode)
mode = GET_MODE (op);
/* Don't accept CONST_INT or anything similar
if the caller wants something floating. */
if (GET_MODE (op) == VOIDmode && mode != VOIDmode
&& GET_MODE_CLASS (mode) != MODE_INT
&& GET_MODE_CLASS (mode) != MODE_PARTIAL_INT)
return false;
if (CONST_INT_P (op)
&& mode != VOIDmode
&& trunc_int_for_mode (INTVAL (op), mode) != INTVAL (op))
return false;
if (CONSTANT_P (op))
return ((GET_MODE (op) == VOIDmode || GET_MODE (op) == mode
|| mode == VOIDmode)
&& (! flag_pic || LEGITIMATE_PIC_OPERAND_P (op))
&& targetm.legitimate_constant_p (mode == VOIDmode
? GET_MODE (op)
: mode, op));
/* Except for certain constants with VOIDmode, already checked for,
OP's mode must match MODE if MODE specifies a mode. */
if (GET_MODE (op) != mode)
return false;
if (code == SUBREG)
{
rtx sub = SUBREG_REG (op);
#ifdef INSN_SCHEDULING
/* On machines that have insn scheduling, we want all memory
reference to be explicit, so outlaw paradoxical SUBREGs.
However, we must allow them after reload so that they can
get cleaned up by cleanup_subreg_operands. */
if (!reload_completed && MEM_P (sub)
&& paradoxical_subreg_p (op))
return false;
#endif
/* Avoid memories with nonzero SUBREG_BYTE, as offsetting the memory
may result in incorrect reference. We should simplify all valid
subregs of MEM anyway. But allow this after reload because we
might be called from cleanup_subreg_operands.
??? This is a kludge. */
if (!reload_completed
&& maybe_ne (SUBREG_BYTE (op), 0)
&& MEM_P (sub))
return false;
if (REG_P (sub)
&& REGNO (sub) < FIRST_PSEUDO_REGISTER
&& !REG_CAN_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_FLOAT
/* LRA can generate some invalid SUBREGS just for matched
operand reload presentation. LRA needs to treat them as
valid. */
&& ! LRA_SUBREG_P (op))
return false;
/* FLOAT_MODE subregs can't be paradoxical. Combine will occasionally
create such rtl, and we must reject it. */
if (SCALAR_FLOAT_MODE_P (GET_MODE (op))
/* LRA can use subreg to store a floating point value in an
integer mode. Although the floating point and the
integer modes need the same number of hard registers, the
size of floating point mode can be less than the integer
mode. */
&& ! lra_in_progress
&& paradoxical_subreg_p (op))
return false;
op = sub;
code = GET_CODE (op);
}
if (code == REG)
return (REGNO (op) >= FIRST_PSEUDO_REGISTER
|| in_hard_reg_set_p (operand_reg_set, GET_MODE (op), REGNO (op)));
if (code == MEM)
{
rtx y = XEXP (op, 0);
if (! volatile_ok && MEM_VOLATILE_P (op))
return false;
/* Use the mem's mode, since it will be reloaded thus. LRA can
generate move insn with invalid addresses which is made valid
and efficiently calculated by LRA through further numerous
transformations. */
if (lra_in_progress
|| memory_address_addr_space_p (GET_MODE (op), y, MEM_ADDR_SPACE (op)))
return true;
}
return false;
}
/* Return true if OP is a valid memory address for a memory reference
of mode MODE.
The main use of this function is as a predicate in match_operand
expressions in the machine description. */
bool
address_operand (rtx op, machine_mode mode)
{
/* Wrong mode for an address expr. */
if (GET_MODE (op) != VOIDmode
&& ! SCALAR_INT_MODE_P (GET_MODE (op)))
return false;
return memory_address_p (mode, op);
}
/* Return true if OP is a register reference of mode MODE.
If MODE is VOIDmode, accept a register in any mode.
The main use of this function is as a predicate in match_operand
expressions in the machine description. */
bool
register_operand (rtx op, machine_mode mode)
{
if (GET_CODE (op) == SUBREG)
{
rtx sub = SUBREG_REG (op);
/* Before reload, we can allow (SUBREG (MEM...)) as a register operand
because it is guaranteed to be reloaded into one.
Just make sure the MEM is valid in itself.
(Ideally, (SUBREG (MEM)...) should not exist after reload,
but currently it does result from (SUBREG (REG)...) where the
reg went on the stack.) */
if (!REG_P (sub) && (reload_completed || !MEM_P (sub)))
return false;
}
else if (!REG_P (op))
return false;
return general_operand (op, mode);
}
/* Return true for a register in Pmode; ignore the tested mode. */
bool
pmode_register_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
{
return register_operand (op, Pmode);
}
/* Return true if OP should match a MATCH_SCRATCH, i.e., if it is a SCRATCH
or a hard register. */
bool
scratch_operand (rtx op, machine_mode mode)
{
if (GET_MODE (op) != mode && mode != VOIDmode)
return false;
return (GET_CODE (op) == SCRATCH
|| (REG_P (op)
&& (lra_in_progress
|| (REGNO (op) < FIRST_PSEUDO_REGISTER
&& REGNO_REG_CLASS (REGNO (op)) != NO_REGS))));
}
/* Return true if OP is a valid immediate operand for mode MODE.
The main use of this function is as a predicate in match_operand
expressions in the machine description. */
bool
immediate_operand (rtx op, machine_mode mode)
{
/* Don't accept CONST_INT or anything similar
if the caller wants something floating. */
if (GET_MODE (op) == VOIDmode && mode != VOIDmode
&& GET_MODE_CLASS (mode) != MODE_INT
&& GET_MODE_CLASS (mode) != MODE_PARTIAL_INT)
return false;
if (CONST_INT_P (op)
&& mode != VOIDmode
&& trunc_int_for_mode (INTVAL (op), mode) != INTVAL (op))
return false;
return (CONSTANT_P (op)
&& (GET_MODE (op) == mode || mode == VOIDmode
|| GET_MODE (op) == VOIDmode)
&& (! flag_pic || LEGITIMATE_PIC_OPERAND_P (op))
&& targetm.legitimate_constant_p (mode == VOIDmode
? GET_MODE (op)
: mode, op));
}
/* Return true if OP is an operand that is a CONST_INT of mode MODE. */
bool
const_int_operand (rtx op, machine_mode mode)
{
if (!CONST_INT_P (op))
return false;
if (mode != VOIDmode
&& trunc_int_for_mode (INTVAL (op), mode) != INTVAL (op))
return false;
return true;
}
#if TARGET_SUPPORTS_WIDE_INT
/* Return true if OP is an operand that is a CONST_INT or CONST_WIDE_INT
of mode MODE. */
bool
const_scalar_int_operand (rtx op, machine_mode mode)
{
if (!CONST_SCALAR_INT_P (op))
return false;
if (CONST_INT_P (op))
return const_int_operand (op, mode);
if (mode != VOIDmode)
{
scalar_int_mode int_mode = as_a <scalar_int_mode> (mode);
int prec = GET_MODE_PRECISION (int_mode);
int bitsize = GET_MODE_BITSIZE (int_mode);
if (CONST_WIDE_INT_NUNITS (op) * HOST_BITS_PER_WIDE_INT > bitsize)
return false;
if (prec == bitsize)
return true;
else
{
/* Multiword partial int. */
HOST_WIDE_INT x
= CONST_WIDE_INT_ELT (op, CONST_WIDE_INT_NUNITS (op) - 1);
return (sext_hwi (x, prec & (HOST_BITS_PER_WIDE_INT - 1)) == x);
}
}
return true;
}
/* Return true if OP is an operand that is a constant integer or constant
floating-point number of MODE. */
bool
const_double_operand (rtx op, machine_mode mode)
{
return (GET_CODE (op) == CONST_DOUBLE)
&& (GET_MODE (op) == mode || mode == VOIDmode);
}
#else
/* Return true if OP is an operand that is a constant integer or constant
floating-point number of MODE. */
bool
const_double_operand (rtx op, machine_mode mode)
{
/* Don't accept CONST_INT or anything similar
if the caller wants something floating. */
if (GET_MODE (op) == VOIDmode && mode != VOIDmode
&& GET_MODE_CLASS (mode) != MODE_INT
&& GET_MODE_CLASS (mode) != MODE_PARTIAL_INT)
return false;
return ((CONST_DOUBLE_P (op) || CONST_INT_P (op))
&& (mode == VOIDmode || GET_MODE (op) == mode
|| GET_MODE (op) == VOIDmode));
}
#endif
/* Return true if OP is a general operand that is not an immediate
operand of mode MODE. */
bool
nonimmediate_operand (rtx op, machine_mode mode)
{
return (general_operand (op, mode) && ! CONSTANT_P (op));
}
/* Return true if OP is a register reference or
immediate value of mode MODE. */
bool
nonmemory_operand (rtx op, machine_mode mode)
{
if (CONSTANT_P (op))
return immediate_operand (op, mode);
return register_operand (op, mode);
}
/* Return true if OP is a valid operand that stands for pushing a
value of mode MODE onto the stack.
The main use of this function is as a predicate in match_operand
expressions in the machine description. */
bool
push_operand (rtx op, machine_mode mode)
{
if (!MEM_P (op))
return false;
if (mode != VOIDmode && GET_MODE (op) != mode)
return false;
poly_int64 rounded_size = GET_MODE_SIZE (mode);
#ifdef PUSH_ROUNDING
rounded_size = PUSH_ROUNDING (MACRO_INT (rounded_size));
#endif
op = XEXP (op, 0);
if (known_eq (rounded_size, GET_MODE_SIZE (mode)))
{
if (GET_CODE (op) != STACK_PUSH_CODE)
return false;
}
else
{
poly_int64 offset;
if (GET_CODE (op) != PRE_MODIFY
|| GET_CODE (XEXP (op, 1)) != PLUS
|| XEXP (XEXP (op, 1), 0) != XEXP (op, 0)
|| !poly_int_rtx_p (XEXP (XEXP (op, 1), 1), &offset)
|| (STACK_GROWS_DOWNWARD
? maybe_ne (offset, -rounded_size)
: maybe_ne (offset, rounded_size)))
return false;
}
return XEXP (op, 0) == stack_pointer_rtx;
}
/* Return true if OP is a valid operand that stands for popping a
value of mode MODE off the stack.
The main use of this function is as a predicate in match_operand
expressions in the machine description. */
bool
pop_operand (rtx op, machine_mode mode)
{
if (!MEM_P (op))
return false;
if (mode != VOIDmode && GET_MODE (op) != mode)
return false;
op = XEXP (op, 0);
if (GET_CODE (op) != STACK_POP_CODE)
return false;
return XEXP (op, 0) == stack_pointer_rtx;
}
/* Return true if ADDR is a valid memory address
for mode MODE in address space AS. */
bool
memory_address_addr_space_p (machine_mode mode ATTRIBUTE_UNUSED,
rtx addr, addr_space_t as)
{
#ifdef GO_IF_LEGITIMATE_ADDRESS
gcc_assert (ADDR_SPACE_GENERIC_P (as));
GO_IF_LEGITIMATE_ADDRESS (mode, addr, win);
return false;
win:
return true;
#else
return targetm.addr_space.legitimate_address_p (mode, addr, 0, as);
#endif
}
/* Return true if OP is a valid memory reference with mode MODE,
including a valid address.
The main use of this function is as a predicate in match_operand
expressions in the machine description. */
bool
memory_operand (rtx op, machine_mode mode)
{
rtx inner;
if (! reload_completed)
/* Note that no SUBREG is a memory operand before end of reload pass,
because (SUBREG (MEM...)) forces reloading into a register. */
return MEM_P (op) && general_operand (op, mode);
if (mode != VOIDmode && GET_MODE (op) != mode)
return false;
inner = op;
if (GET_CODE (inner) == SUBREG)
inner = SUBREG_REG (inner);
return (MEM_P (inner) && general_operand (op, mode));
}
/* Return true if OP is a valid indirect memory reference with mode MODE;
that is, a memory reference whose address is a general_operand. */
bool
indirect_operand (rtx op, machine_mode mode)
{
/* Before reload, a SUBREG isn't in memory (see memory_operand, above). */
if (! reload_completed
&& GET_CODE (op) == SUBREG && MEM_P (SUBREG_REG (op)))
{
if (mode != VOIDmode && GET_MODE (op) != mode)
return false;
/* 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
or if the address is (plus Y (const_int -OFFSET)) and Y is an
operand. */
poly_int64 offset;
rtx addr = strip_offset (XEXP (SUBREG_REG (op), 0), &offset);
return (known_eq (offset + SUBREG_BYTE (op), 0)
&& general_operand (addr, Pmode));
}
return (MEM_P (op)
&& memory_operand (op, mode)
&& general_operand (XEXP (op, 0), Pmode));
}
/* Return true if this is an ordered comparison operator (not including
ORDERED and UNORDERED). */
bool
ordered_comparison_operator (rtx op, machine_mode mode)
{
if (mode != VOIDmode && GET_MODE (op) != mode)
return false;
switch (GET_CODE (op))
{
case EQ:
case NE:
case LT:
case LTU:
case LE:
case LEU:
case GT:
case GTU:
case GE:
case GEU:
return true;
default:
return false;
}
}
/* Return true if this is a comparison operator. This allows the use of
MATCH_OPERATOR to recognize all the branch insns. */
bool
comparison_operator (rtx op, machine_mode mode)
{
return ((mode == VOIDmode || GET_MODE (op) == mode)
&& COMPARISON_P (op));
}
/* If BODY is an insn body that uses ASM_OPERANDS, return it. */
rtx
extract_asm_operands (rtx body)
{
rtx tmp;
switch (GET_CODE (body))
{
case ASM_OPERANDS:
return body;
case SET:
/* Single output operand: BODY is (set OUTPUT (asm_operands ...)). */
tmp = SET_SRC (body);
if (GET_CODE (tmp) == ASM_OPERANDS)
return tmp;
break;
case PARALLEL:
tmp = XVECEXP (body, 0, 0);
if (GET_CODE (tmp) == ASM_OPERANDS)
return tmp;
if (GET_CODE (tmp) == SET)
{
tmp = SET_SRC (tmp);
if (GET_CODE (tmp) == ASM_OPERANDS)
return tmp;
}
break;
default:
break;
}
return NULL;
}
/* If BODY is an insn body that uses ASM_OPERANDS,
return the number of operands (both input and output) in the insn.
If BODY is an insn body that uses ASM_INPUT with CLOBBERS in PARALLEL,
return 0.
Otherwise return -1. */
int
asm_noperands (const_rtx body)
{
rtx asm_op = extract_asm_operands (CONST_CAST_RTX (body));
int i, n_sets = 0;
if (asm_op == NULL)
{
if (GET_CODE (body) == PARALLEL && XVECLEN (body, 0) >= 2
&& GET_CODE (XVECEXP (body, 0, 0)) == ASM_INPUT)
{
/* body is [(asm_input ...) (clobber (reg ...))...]. */
for (i = XVECLEN (body, 0) - 1; i > 0; i--)
if (GET_CODE (XVECEXP (body, 0, i)) != CLOBBER)
return -1;
return 0;
}
return -1;
}
if (GET_CODE (body) == SET)
n_sets = 1;
else if (GET_CODE (body) == PARALLEL)
{
if (GET_CODE (XVECEXP (body, 0, 0)) == SET)
{
/* Multiple output operands, or 1 output plus some clobbers:
body is
[(set OUTPUT (asm_operands ...))... (clobber (reg ...))...]. */
/* Count backwards through CLOBBERs to determine number of SETs. */
for (i = XVECLEN (body, 0); i > 0; i--)
{
if (GET_CODE (XVECEXP (body, 0, i - 1)) == SET)
break;
if (GET_CODE (XVECEXP (body, 0, i - 1)) != CLOBBER)
return -1;
}
/* N_SETS is now number of output operands. */
n_sets = i;
/* Verify that all the SETs we have
came from a single original asm_operands insn
(so that invalid combinations are blocked). */
for (i = 0; i < n_sets; i++)
{
rtx elt = XVECEXP (body, 0, i);
if (GET_CODE (elt) != SET)
return -1;
if (GET_CODE (SET_SRC (elt)) != ASM_OPERANDS)
return -1;
/* If these ASM_OPERANDS rtx's came from different original insns
then they aren't allowed together. */
if (ASM_OPERANDS_INPUT_VEC (SET_SRC (elt))
!= ASM_OPERANDS_INPUT_VEC (asm_op))
return -1;
}
}
else
{
/* 0 outputs, but some clobbers:
body is [(asm_operands ...) (clobber (reg ...))...]. */
/* Make sure all the other parallel things really are clobbers. */
for (i = XVECLEN (body, 0) - 1; i > 0; i--)
if (GET_CODE (XVECEXP (body, 0, i)) != CLOBBER)
return -1;
}
}
return (ASM_OPERANDS_INPUT_LENGTH (asm_op)
+ ASM_OPERANDS_LABEL_LENGTH (asm_op) + n_sets);
}
/* Assuming BODY is an insn body that uses ASM_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,
and the constraints for the operands into CONSTRAINTS.
Write the modes of the operands into MODES.
Write the location info into LOC.
Return the assembler-template.
If BODY is an insn body that uses ASM_INPUT with CLOBBERS in PARALLEL,
return the basic assembly string.
If LOC, MODES, OPERAND_LOCS, CONSTRAINTS or OPERANDS is 0,
we don't store that info. */
const char *
decode_asm_operands (rtx body, rtx *operands, rtx **operand_locs,
const char **constraints, machine_mode *modes,
location_t *loc)
{
int nbase = 0, n, i;
rtx asmop;
switch (GET_CODE (body))
{
case ASM_OPERANDS:
/* Zero output asm: BODY is (asm_operands ...). */
asmop = body;
break;
case SET:
/* Single output asm: BODY is (set OUTPUT (asm_operands ...)). */
asmop = SET_SRC (body);
/* The output is in the SET.
Its constraint is in the ASM_OPERANDS itself. */
if (operands)
operands[0] = SET_DEST (body);
if (operand_locs)
operand_locs[0] = &SET_DEST (body);
if (constraints)
constraints[0] = ASM_OPERANDS_OUTPUT_CONSTRAINT (asmop);
if (modes)
modes[0] = GET_MODE (SET_DEST (body));
nbase = 1;
break;
case PARALLEL:
{
int nparallel = XVECLEN (body, 0); /* Includes CLOBBERs. */
asmop = XVECEXP (body, 0, 0);
if (GET_CODE (asmop) == SET)
{
asmop = SET_SRC (asmop);
/* At least one output, plus some CLOBBERs. The outputs are in
the SETs. Their constraints are in the ASM_OPERANDS itself. */
for (i = 0; i < nparallel; i++)
{
if (GET_CODE (XVECEXP (body, 0, i)) == CLOBBER)
break; /* Past last SET */
gcc_assert (GET_CODE (XVECEXP (body, 0, i)) == SET);
if (operands)
operands[i] = SET_DEST (XVECEXP (body, 0, i));
if (operand_locs)
operand_locs[i] = &SET_DEST (XVECEXP (body, 0, i));
if (constraints)
constraints[i] = XSTR (SET_SRC (XVECEXP (body, 0, i)), 1);
if (modes)
modes[i] = GET_MODE (SET_DEST (XVECEXP (body, 0, i)));
}
nbase = i;
}
else if (GET_CODE (asmop) == ASM_INPUT)
{
if (loc)
*loc = ASM_INPUT_SOURCE_LOCATION (asmop);
return XSTR (asmop, 0);
}
break;
}
default:
gcc_unreachable ();
}
n = ASM_OPERANDS_INPUT_LENGTH (asmop);
for (i = 0; i < n; i++)
{
if (operand_locs)
operand_locs[nbase + i] = &ASM_OPERANDS_INPUT (asmop, i);
if (operands)
operands[nbase + i] = ASM_OPERANDS_INPUT (asmop, i);
if (constraints)
constraints[nbase + i] = ASM_OPERANDS_INPUT_CONSTRAINT (asmop, i);
if (modes)
modes[nbase + i] = ASM_OPERANDS_INPUT_MODE (asmop, i);
}
nbase += n;
n = ASM_OPERANDS_LABEL_LENGTH (asmop);
for (i = 0; i < n; i++)
{
if (operand_locs)
operand_locs[nbase + i] = &ASM_OPERANDS_LABEL (asmop, i);
if (operands)
operands[nbase + i] = ASM_OPERANDS_LABEL (asmop, i);
if (constraints)
constraints[nbase + i] = "";
if (modes)
modes[nbase + i] = Pmode;
}
if (loc)
*loc = ASM_OPERANDS_SOURCE_LOCATION (asmop);
return ASM_OPERANDS_TEMPLATE (asmop);
}
/* Parse inline assembly string STRING and determine which operands are
referenced by % markers. For the first NOPERANDS operands, set USED[I]
to true if operand I is referenced.
This is intended to distinguish barrier-like asms such as:
asm ("" : "=m" (...));
from real references such as:
asm ("sw\t$0, %0" : "=m" (...)); */
void
get_referenced_operands (const char *string, bool *used,
unsigned int noperands)
{
memset (used, 0, sizeof (bool) * noperands);
const char *p = string;
while (*p)
switch (*p)
{
case '%':
p += 1;
/* A letter followed by a digit indicates an operand number. */
if (ISALPHA (p[0]) && ISDIGIT (p[1]))
p += 1;
if (ISDIGIT (*p))
{
char *endptr;
unsigned long opnum = strtoul (p, &endptr, 10);
if (endptr != p && opnum < noperands)
used[opnum] = true;
p = endptr;
}
else
p += 1;
break;
default:
p++;
break;
}
}
/* Check if an asm_operand matches its constraints.
Return > 0 if ok, = 0 if bad, < 0 if inconclusive. */
int
asm_operand_ok (rtx op, const char *constraint, const char **constraints)
{
int result = 0;
bool incdec_ok = false;
/* Use constrain_operands after reload. */
gcc_assert (!reload_completed);
/* Empty constraint string is the same as "X,...,X", i.e. X for as
many alternatives as required to match the other operands. */
if (*constraint == '\0')
result = 1;
while (*constraint)
{
enum constraint_num cn;
char c = *constraint;
int len;
switch (c)
{
case ',':
constraint++;
continue;
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
/* If caller provided constraints pointer, look up
the matching constraint. Otherwise, our caller should have
given us the proper matching constraint, but we can't
actually fail the check if they didn't. Indicate that
results are inconclusive. */
if (constraints)
{
char *end;
unsigned long match;
match = strtoul (constraint, &end, 10);
if (!result)
result = asm_operand_ok (op, constraints[match], NULL);
constraint = (const char *) end;
}
else
{
do
constraint++;
while (ISDIGIT (*constraint));
if (! result)
result = -1;
}
continue;
/* The rest of the compiler assumes that reloading the address
of a MEM into a register will make it fit an 'o' constraint.
That is, if it sees a MEM operand for an 'o' constraint,
it assumes that (mem (base-reg)) will fit.
That assumption fails on targets that don't have offsettable
addresses at all. We therefore need to treat 'o' asm
constraints as a special case and only accept operands that
are already offsettable, thus proving that at least one
offsettable address exists. */
case 'o': /* offsettable */
if (offsettable_nonstrict_memref_p (op))
result = 1;
break;
case 'g':
if (general_operand (op, VOIDmode))
result = 1;
break;
case '<':
case '>':
/* ??? Before auto-inc-dec, auto inc/dec insns are not supposed
to exist, excepting those that expand_call created. Further,
on some machines which do not have generalized auto inc/dec,
an inc/dec is not a memory_operand.
Match any memory and hope things are resolved after reload. */
incdec_ok = true;
/* FALLTHRU */
default:
cn = lookup_constraint (constraint);
rtx mem = NULL;
switch (get_constraint_type (cn))
{
case CT_REGISTER:
if (!result
&& reg_class_for_constraint (cn) != NO_REGS
&& GET_MODE (op) != BLKmode
&& register_operand (op, VOIDmode))
result = 1;
break;
case CT_CONST_INT:
if (!result
&& CONST_INT_P (op)
&& insn_const_int_ok_for_constraint (INTVAL (op), cn))
result = 1;
break;
case CT_MEMORY:
case CT_RELAXED_MEMORY:
mem = op;
/* Fall through. */
case CT_SPECIAL_MEMORY:
/* Every memory operand can be reloaded to fit. */
if (!mem)
mem = extract_mem_from_operand (op);
result = result || memory_operand (mem, VOIDmode);
break;
case CT_ADDRESS:
/* Every address operand can be reloaded to fit. */
result = result || address_operand (op, VOIDmode);
break;
case CT_FIXED_FORM:
result = result || constraint_satisfied_p (op, cn);
break;
}
break;
}
len = CONSTRAINT_LEN (c, constraint);
do
constraint++;
while (--len && *constraint && *constraint != ',');
if (len)
return 0;
}
/* For operands without < or > constraints reject side-effects. */
if (AUTO_INC_DEC && !incdec_ok && result && MEM_P (op))
switch (GET_CODE (XEXP (op, 0)))
{
case PRE_INC:
case POST_INC:
case PRE_DEC:
case POST_DEC:
case PRE_MODIFY:
case POST_MODIFY:
return 0;
default:
break;
}
return result;
}
/* 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.
Otherwise, return a null pointer. */
rtx *
find_constant_term_loc (rtx *p)
{
rtx *tem;
enum rtx_code code = GET_CODE (*p);
/* If *P IS such a constant term, P is its location. */
if (code == CONST_INT || code == SYMBOL_REF || code == LABEL_REF
|| code == CONST)
return p;
/* Otherwise, if not a sum, it has no constant term. */
if (GET_CODE (*p) != PLUS)
return 0;
/* If one of the summands is constant, return its location. */
if (XEXP (*p, 0) && CONSTANT_P (XEXP (*p, 0))
&& XEXP (*p, 1) && CONSTANT_P (XEXP (*p, 1)))
return p;
/* Otherwise, check each summand for containing a constant term. */
if (XEXP (*p, 0) != 0)
{
tem = find_constant_term_loc (&XEXP (*p, 0));
if (tem != 0)
return tem;
}
if (XEXP (*p, 1) != 0)
{
tem = find_constant_term_loc (&XEXP (*p, 1));
if (tem != 0)
return tem;
}
return 0;
}
/* Return true if OP is a memory reference whose address contains
no side effects and remains valid after the addition of a positive
integer less than the size of the object being referenced.
We assume that the original address is valid and do not check it.
This uses strict_memory_address_p as a subroutine, so
don't use it before reload. */
bool
offsettable_memref_p (rtx op)
{
return ((MEM_P (op))
&& offsettable_address_addr_space_p (1, GET_MODE (op), XEXP (op, 0),
MEM_ADDR_SPACE (op)));
}
/* Similar, but don't require a strictly valid mem ref:
consider pseudo-regs valid as index or base regs. */
bool
offsettable_nonstrict_memref_p (rtx op)
{
return ((MEM_P (op))
&& offsettable_address_addr_space_p (0, GET_MODE (op), XEXP (op, 0),
MEM_ADDR_SPACE (op)));
}
/* Return true if Y is a memory address which contains no side effects
and would remain valid for address space AS after the addition of
a positive integer less than the size of that mode.
We assume that the original address is valid and do not check it.
We do check that it is valid for narrower modes.
If STRICTP is nonzero, we require a strictly valid address,
for the sake of use in reload.c. */
bool
offsettable_address_addr_space_p (int strictp, machine_mode mode, rtx y,
addr_space_t as)
{
enum rtx_code ycode = GET_CODE (y);
rtx z;
rtx y1 = y;
rtx *y2;
bool (*addressp) (machine_mode, rtx, addr_space_t) =
(strictp ? strict_memory_address_addr_space_p
: memory_address_addr_space_p);
poly_int64 mode_sz = GET_MODE_SIZE (mode);
if (CONSTANT_ADDRESS_P (y))
return true;
/* Adjusting an offsettable address involves changing to a narrower mode.
Make sure that's OK. */
if (mode_dependent_address_p (y, as))
return false;
machine_mode address_mode = GET_MODE (y);
if (address_mode == VOIDmode)
address_mode = targetm.addr_space.address_mode (as);
#ifdef POINTERS_EXTEND_UNSIGNED
machine_mode pointer_mode = targetm.addr_space.pointer_mode (as);
#endif
/* ??? How much offset does an offsettable BLKmode reference need?
Clearly that depends on the situation in which it's being used.
However, the current situation in which we test 0xffffffff is
less than ideal. Caveat user. */
if (known_eq (mode_sz, 0))
mode_sz = BIGGEST_ALIGNMENT / BITS_PER_UNIT;
/* If the expression contains a constant term,
see if it remains valid when max possible offset is added. */
if ((ycode == PLUS) && (y2 = find_constant_term_loc (&y1)))
{
bool good;
y1 = *y2;
*y2 = plus_constant (address_mode, *y2, mode_sz - 1);
/* Use QImode because an odd displacement may be automatically invalid
for any wider mode. But it should be valid for a single byte. */
good = (*addressp) (QImode, y, as);
/* In any case, restore old contents of memory. */
*y2 = y1;
return good;
}
if (GET_RTX_CLASS (ycode) == RTX_AUTOINC)
return false;
/* The offset added here is chosen as the maximum offset that
any instruction could need to add when operating on something
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
go inside a LO_SUM here, so we do so as well. */
if (GET_CODE (y) == LO_SUM
&& mode != BLKmode
&& known_le (mode_sz, GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT))
z = gen_rtx_LO_SUM (address_mode, XEXP (y, 0),
plus_constant (address_mode, XEXP (y, 1),
mode_sz - 1));
#ifdef POINTERS_EXTEND_UNSIGNED
/* Likewise for a ZERO_EXTEND from pointer_mode. */
else if (POINTERS_EXTEND_UNSIGNED > 0
&& GET_CODE (y) == ZERO_EXTEND
&& GET_MODE (XEXP (y, 0)) == pointer_mode)
z = gen_rtx_ZERO_EXTEND (address_mode,
plus_constant (pointer_mode, XEXP (y, 0),
mode_sz - 1));
#endif
else
z = plus_constant (address_mode, y, mode_sz - 1);
/* Use QImode because an odd displacement may be automatically invalid
for any wider mode. But it should be valid for a single byte. */
return (*addressp) (QImode, z, as);
}
/* Return true if ADDR is an address-expression whose effect depends
on the mode of the memory reference it is used in.
ADDRSPACE is the address space associated with the address.
Autoincrement addressing is a typical example of mode-dependence
because the amount of the increment depends on the mode. */
bool
mode_dependent_address_p (rtx addr, addr_space_t addrspace)
{
/* Auto-increment addressing with anything other than post_modify
or pre_modify always introduces a mode dependency. Catch such
cases now instead of deferring to the target. */
if (GET_CODE (addr) == PRE_INC
|| GET_CODE (addr) == POST_INC
|| GET_CODE (addr) == PRE_DEC
|| GET_CODE (addr) == POST_DEC)
return true;
return targetm.mode_dependent_address_p (addr, addrspace);
}
/* Return true if boolean attribute ATTR is supported. */
static bool
have_bool_attr (bool_attr attr)
{
switch (attr)
{
case BA_ENABLED:
return HAVE_ATTR_enabled;
case BA_PREFERRED_FOR_SIZE:
return HAVE_ATTR_enabled || HAVE_ATTR_preferred_for_size;
case BA_PREFERRED_FOR_SPEED:
return HAVE_ATTR_enabled || HAVE_ATTR_preferred_for_speed;
}
gcc_unreachable ();
}
/* Return the value of ATTR for instruction INSN. */
static bool
get_bool_attr (rtx_insn *insn, bool_attr attr)
{
switch (attr)
{
case BA_ENABLED:
return get_attr_enabled (insn);
case BA_PREFERRED_FOR_SIZE:
return get_attr_enabled (insn) && get_attr_preferred_for_size (insn);
case BA_PREFERRED_FOR_SPEED:
return get_attr_enabled (insn) && get_attr_preferred_for_speed (insn);
}
gcc_unreachable ();
}
/* Like get_bool_attr_mask, but don't use the cache. */
static alternative_mask
get_bool_attr_mask_uncached (rtx_insn *insn, bool_attr attr)
{
/* Temporarily install enough information for get_attr_<foo> to assume
that the insn operands are already cached. As above, the attribute
mustn't depend on the values of operands, so we don't provide their
real values here. */
rtx_insn *old_insn = recog_data.insn;
int old_alternative = which_alternative;
recog_data.insn = insn;
alternative_mask mask = ALL_ALTERNATIVES;
int n_alternatives = insn_data[INSN_CODE (insn)].n_alternatives;
for (int i = 0; i < n_alternatives; i++)
{
which_alternative = i;
if (!get_bool_attr (insn, attr))
mask &= ~ALTERNATIVE_BIT (i);
}
recog_data.insn = old_insn;
which_alternative = old_alternative;
return mask;
}
/* Return the mask of operand alternatives that are allowed for INSN
by boolean attribute ATTR. This mask depends only on INSN and on
the current target; it does not depend on things like the values of
operands. */
static alternative_mask
get_bool_attr_mask (rtx_insn *insn, bool_attr attr)
{
/* Quick exit for asms and for targets that don't use these attributes. */
int code = INSN_CODE (insn);
if (code < 0 || !have_bool_attr (attr))
return ALL_ALTERNATIVES;
/* Calling get_attr_<foo> can be expensive, so cache the mask
for speed. */
if (!this_target_recog->x_bool_attr_masks[code][attr])
this_target_recog->x_bool_attr_masks[code][attr]
= get_bool_attr_mask_uncached (insn, attr);
return this_target_recog->x_bool_attr_masks[code][attr];
}
/* Return the set of alternatives of INSN that are allowed by the current
target. */
alternative_mask
get_enabled_alternatives (rtx_insn *insn)
{
return get_bool_attr_mask (insn, BA_ENABLED);
}
/* Return the set of alternatives of INSN that are allowed by the current
target and are preferred for the current size/speed optimization
choice. */
alternative_mask
get_preferred_alternatives (rtx_insn *insn)
{
if (optimize_bb_for_speed_p (BLOCK_FOR_INSN (insn)))
return get_bool_attr_mask (insn, BA_PREFERRED_FOR_SPEED);
else
return get_bool_attr_mask (insn, BA_PREFERRED_FOR_SIZE);
}
/* Return the set of alternatives of INSN that are allowed by the current
target and are preferred for the size/speed optimization choice
associated with BB. Passing a separate BB is useful if INSN has not
been emitted yet or if we are considering moving it to a different
block. */
alternative_mask
get_preferred_alternatives (rtx_insn *insn, basic_block bb)
{
if (optimize_bb_for_speed_p (bb))
return get_bool_attr_mask (insn, BA_PREFERRED_FOR_SPEED);
else
return get_bool_attr_mask (insn, BA_PREFERRED_FOR_SIZE);
}
/* Assert that the cached boolean attributes for INSN are still accurate.
The backend is required to define these attributes in a way that only
depends on the current target (rather than operands, compiler phase,
etc.). */
bool
check_bool_attrs (rtx_insn *insn)
{
int code = INSN_CODE (insn);
if (code >= 0)
for (int i = 0; i <= BA_LAST; ++i)
{
enum bool_attr attr = (enum bool_attr) i;
if (this_target_recog->x_bool_attr_masks[code][attr])
gcc_assert (this_target_recog->x_bool_attr_masks[code][attr]
== get_bool_attr_mask_uncached (insn, attr));
}
return true;
}
/* 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
valid information. This is used primary by gen_attr infrastructure that
often does extract insn again and again. */
void
extract_insn_cached (rtx_insn *insn)
{
if (recog_data.insn == insn && INSN_CODE (insn) >= 0)
return;
extract_insn (insn);
recog_data.insn = insn;
}
/* Do uncached extract_insn, constrain_operands and complain about failures.
This should be used when extracting a pre-existing constrained instruction
if the caller wants to know which alternative was chosen. */
void
extract_constrain_insn (rtx_insn *insn)
{
extract_insn (insn);
if (!constrain_operands (reload_completed, get_enabled_alternatives (insn)))
fatal_insn_not_found (insn);
}
/* Do cached extract_insn, constrain_operands and complain about failures.
Used by insn_attrtab. */
void
extract_constrain_insn_cached (rtx_insn *insn)
{
extract_insn_cached (insn);
if (which_alternative == -1
&& !constrain_operands (reload_completed,
get_enabled_alternatives (insn)))
fatal_insn_not_found (insn);
}
/* Do cached constrain_operands on INSN and complain about failures. */
int
constrain_operands_cached (rtx_insn *insn, int strict)
{
if (which_alternative == -1)
return constrain_operands (strict, get_enabled_alternatives (insn));
else
return 1;
}
/* Analyze INSN and fill in recog_data. */
void
extract_insn (rtx_insn *insn)
{
int i;
int icode;
int noperands;
rtx body = PATTERN (insn);
recog_data.n_operands = 0;
recog_data.n_alternatives = 0;
recog_data.n_dups = 0;
recog_data.is_asm = false;
switch (GET_CODE (body))
{
case USE:
case CLOBBER:
case ASM_INPUT:
case ADDR_VEC:
case ADDR_DIFF_VEC:
case VAR_LOCATION:
case DEBUG_MARKER:
return;
case SET:
if (GET_CODE (SET_SRC (body)) == ASM_OPERANDS)
goto asm_insn;
else
goto normal_insn;
case PARALLEL:
if ((GET_CODE (XVECEXP (body, 0, 0)) == SET
&& 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_INPUT)
goto asm_insn;
else
goto normal_insn;
case ASM_OPERANDS:
asm_insn:
recog_data.n_operands = noperands = asm_noperands (body);
if (noperands >= 0)
{
/* This insn is an `asm' with operands. */
/* expand_asm_operands makes sure there aren't too many operands. */
gcc_assert (noperands <= MAX_RECOG_OPERANDS);
/* Now get the operand values and constraints out of the insn. */
decode_asm_operands (body, recog_data.operand,
recog_data.operand_loc,
recog_data.constraints,
recog_data.operand_mode, NULL);
memset (recog_data.is_operator, 0, sizeof recog_data.is_operator);
if (noperands > 0)
{
const char *p = recog_data.constraints[0];
recog_data.n_alternatives = 1;
while (*p)
recog_data.n_alternatives += (*p++ == ',');
}
recog_data.is_asm = true;
break;
}
fatal_insn_not_found (insn);
default:
normal_insn:
/* Ordinary insn: recognize it, get the operands via insn_extract
and get the constraints. */
icode = recog_memoized (insn);
if (icode < 0)
fatal_insn_not_found (insn);
recog_data.n_operands = noperands = insn_data[icode].n_operands;
recog_data.n_alternatives = insn_data[icode].n_alternatives;
recog_data.n_dups = insn_data[icode].n_dups;
insn_extract (insn);
for (i = 0; i < noperands; i++)
{
recog_data.constraints[i] = insn_data[icode].operand[i].constraint;
recog_data.is_operator[i] = insn_data[icode].operand[i].is_operator;
recog_data.operand_mode[i] = insn_data[icode].operand[i].mode;
/* VOIDmode match_operands gets mode from their real operand. */
if (recog_data.operand_mode[i] == VOIDmode)
recog_data.operand_mode[i] = GET_MODE (recog_data.operand[i]);
}
}
for (i = 0; i < noperands; i++)
recog_data.operand_type[i]
= (recog_data.constraints[i][0] == '=' ? OP_OUT
: recog_data.constraints[i][0] == '+' ? OP_INOUT
: OP_IN);
gcc_assert (recog_data.n_alternatives <= MAX_RECOG_ALTERNATIVES);
recog_data.insn = NULL;
which_alternative = -1;
}
/* Fill in OP_ALT_BASE for an instruction that has N_OPERANDS
operands, N_ALTERNATIVES alternatives and constraint strings
CONSTRAINTS. OP_ALT_BASE has N_ALTERNATIVES * N_OPERANDS entries
and CONSTRAINTS has N_OPERANDS entries. OPLOC should be passed in
if the insn is an asm statement and preprocessing should take the
asm operands into account, e.g. to determine whether they could be
addresses in constraints that require addresses; it should then
point to an array of pointers to each operand. */
void
preprocess_constraints (int n_operands, int n_alternatives,
const char **constraints,
operand_alternative *op_alt_base,
rtx **oploc)
{
for (int i = 0; i < n_operands; i++)
{
int j;
struct operand_alternative *op_alt;
const char *p = constraints[i];
op_alt = op_alt_base;
for (j = 0; j < n_alternatives; j++, op_alt += n_operand